• Shiro-全面详解（学习总结---从入门到深化）

    目录

    Shiro介绍_Shiro简介

     Shiro介绍_Shiro核心功能

    Shiro介绍_Shiro核心组件 

    Shiro入门_项目搭建 

    Shiro入门_配置文件认证 

    Shiro入门_数据库认证 

    Shiro认证_将Shiro对象交给容器管理 

    Shiro认证_自定义Realm 

    Shiro认证_多Realm认证 

     Shiro认证_多Realm认证策略

    Shiro认证_异常处理

     Shiro认证_散列算法

    Shiro认证_过滤器 

    Shiro认证_获取认证数据

    Shiro认证_Shiro会话

    Shiro认证_会话管理器

    Shiro认证_退出登录 

    Shiro认证_Remember Me 

     Shiro授权_权限表设计

    Shiro授权_数据库查询权限

     Shiro授权_在Realm进行授权

    Shiro授权_过滤器配置鉴权

    Shiro授权_注解配置鉴权 

     Shiro授权_Thymeleaf中进行鉴权

     Shiro授权_缓存

    Shiro介绍_Shiro简介

     Shiro是apache旗下的一个开源安全框架，它可以帮助我们完成身 份认证，授权、加密、会话管理等功能。它有如下特点：

    1、易于理解的API 简单的身份认证，支持多种数据源

    2、简单的授权和鉴权

    3、简单的加密API

    4、支持缓存，以提升应用程序的性能

    5、内置会话管理，适用于Web以及非Web的环境

    6、不跟任何的框架或者容器捆绑，可以独立运行

    认证 

    认证即系统判断用户的身份是否合法，合法可继续访问，不合法则 拒绝访问。常见的用户身份认证方式有：用户名密码登录、二维码 登录、手机短信登录、脸部识别认证、指纹认证等方式。 认证是为了保护系统的隐私数据与资源，用户的身份合法才能访问该系统的资源。

    授权

    授权即认证通过后，根据用户的权限来控制用户访问资源的过程， 拥有资源的访问权限则正常访问，没有权限则拒绝访问。 比如在一 些视频网站中，普通用户登录后只有观看免费视频的权限，而VIP用户登录后，网站会给该用户提供观看VIP视频的权限。 认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐 私数据进行划分，控制不同的用户能够访问不同的资源。 举个例子：认证是公司大门识别你作为员工能进入公司，而授权则是由于你作为公司会计可以进入财务室，查看账目，处理财务数据。

     Shiro介绍_Shiro核心功能

    Authentication：身份认证/登录。

    Authorization：权限验证，即判断用户是否能在系统中做某件 事情。

    Session Management：会话管理，用户登录后就是一次会 话，在没有退出之前，它的所有信息都在会话中，会话可以是 JavaSE环境的，也可以是Web环境的。

    Cryptography：加密，保护数据的安全性。即密码加密存储到 数据库，而不是明文存储。 Web Support：Web 支持，可以非常容易的集成到Web环境。 

    Caching：缓存。在用户登录后，用户信息、拥有的权限不必每 次去查，这样可以提高效率。

    Concurrency：Shiro支持多线程应用的并发验证，即如在一个 线程中开启另一个线程，能把权限自动传播过去。

    Testing：提供测试支持。

    Run As：允许一个用户假装为另一个用户的身份进行访问。

    Remember Me：记住我，即一次登录后，下次再来就不用登 录了。

    Shiro介绍_Shiro核心组件 

     1、Subject

    主体。 Subject 在Shiro中是一个接口，接口中定义了认证授权的相关 方法。程序通过调用 Subject 的方法进行认证授权，而 Subject 使用 SecurityManager 进行认证授权。

    2、SecurityManager

    权限管理器，它是Shiro的核心。通过 SecurityManager 可以完成具体的 认证、授权等操作， SecurityManager 是通过 Authenticator 进行认证，通过 Authorizer 进行授权，通过 SessionManager 进行会话管理。 SecurityManager 是 一个接口，继承了 Authenticator , Authorizer , SessionManager 三个接口。

    2、Authenticator

    认证器。对用户登录时进行身份认证

    3、Authorizer

    授权器。用户认证通过后，在访问功能时需要通过授权器判断用户 是否有此功能的操作权限。

    4、SessionManager

    会话管理。shiro框架定义了一套会话管理，它不依赖web容器的 session，所以shiro可以使用在非web应用上。

    5、Realm

    领域。他是连接数据源+认证功能+授权功能的具体实现。 SecurityManager 通过 Realm 获取用户的身份和权限信息，并对用户进行认证和授权。

    6、SessionDAO

    会话dao，是对会话进行操作的一套接口。它可以将session数据存 储到数据库或缓存服务器中。

    7、CacheManager

    缓存管理，将用户权限数据存储在缓存中，这样可以减少权限查询 次数，提高性能。

    8、Cryptography

    密码管理，Shiro提供了一套加密/解密的组件，方便开发。

    Shiro入门_项目搭建 

    1、准备名为myshiro的mysql数据库

    2、创建SpringBoot项目，加入相关依赖

    1. <dependencies>
    2.     
    3.     <dependency>
    4.         <groupId>org.springframework.bootgroupId>
    5.         <artifactId>spring-boot-starter-webartifactId>
    6.     dependency>
    7.     
    8.     <dependency>
    9.         <groupId>org.springframework.bootgroupId>
    10.         <artifactId>spring-boot-starter-thymeleafartifactId>
    11.     dependency>
    12.     
    13.     <dependency>
    14.         <groupId>mysqlgroupId>
    15.         <artifactId>mysql-connector-javaartifactId>
    16.         <scope>runtimescope>
    17.     dependency>
    18.     
    19.     <dependency>
    20.         <groupId>com.baomidougroupId>
    21.         <artifactId>mybatis-plus-boot-starterartifactId>
    22.         <version>3.5.0version>
    23.     dependency>
    24.     
    25.     <dependency>
    26.        <groupId>org.apache.shirogroupId>
    27.        <artifactId>shiro-springartifactId>
    28.        <version>1.9.0version>
    29.     dependency>
    30.     
    31.     <dependency>
    32.         <groupId>org.projectlombokgroupId>
    33.         <artifactId>lombokartifactId>
    34.         <optional>trueoptional>
    35.     dependency>
    36.     
    37.     <dependency>
    38.         <groupId>org.springframework.bootgroupId>
    39.         <artifactId>spring-boot-starter-testartifactId>
    40.         <scope>testscope>
    41.     dependency>
    42.     
    43.     <dependency>
    44.         <groupId>org.springframework.bootgroupId>
    45.         <artifactId>spring-boot-starter-jdbcartifactId>
    46.     dependency>
    47. dependencies>

    3、编写配置文件 application.yml

    1. server:
    2.   port: 80
    3. #日志格式
    4. logging:
    5.   pattern:
    6.     console: '%d{HH:mm:ss.SSS} %clr(%-5level) --- [%-15thread]
    7. %cyan(%-50logger{50}):%msg%n'
    8. # 数据源
    9. spring:
    10.  datasource:
    11.    driver-class-name: com.mysql.cj.jdbc.Driver
    12.    url: jdbc:mysql:///myshiro?serverTimezone=UTC
    13.    username: root
    14.    password01: root

    4、将前端资源复制到项目中

    5、编写页面跳转控制器

    1. @Controller
    2. public class PageController {
    3.     @RequestMapping("/{page}")
    4.     public String showPage(@PathVariable String page) {
    5.         return page;
    6.    }
    7.     // 忽略favicon.ico的获取
    8.     @GetMapping("favicon.ico")
    9.     @ResponseBody
    10.     public void noFavicon() {}
    11. }

    6、启动项目，访问登录页http://localhost/login

    Shiro入门_配置文件认证 

    Shrio支持多种数据源，我们首先将用户名密码写入配置文件，让 Shiro读取配置文件进行认证。 

     1、在 resources 目录下编写配置文件 shiro.ini

    1. #声明用户账号
    2. [users]
    3. baizhan=123

    2、编写登录控制器方法

    1. @Controller
    2. public class LoginController {
    3.     @RequestMapping("/user/login")
    4.     public String login(String username,String password){
    5.         // 1.获取SecurityManager工厂，读取配置文件
    6.         IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    7.         // 2.获取SecurityManager对象
    8.         SecurityManager securityManager = factory.getInstance();
    9.         // 3.将SecurityManager对象设置到运行环境中
    10.       SecurityUtils.setSecurityManager(securityManager);
    11.         // 4.获取Subject对象
    12.         Subject subject = SecurityUtils.getSubject();
    13.         // 5.将前端传来的用户名密码封装为Shiro提供的身份对象
    14.         UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    15.         try {
    16.         // 6.shiro认证
    17.             subject.login(token);
    18.             // 7.认证通过跳转到主页面
    19.             return "main";
    20.        }catch (AuthenticationException e)
    21.        {
    22.             // 8.认证不通过跳转到失败页面
    23.             return "fail";
    24.        }
    25.    }
    26. }

    3、启动项目，访问登录页http://localhost/login，测试登录功能。

    Shiro入门_数据库认证 

     之前我们使用配置文件做数据源，在真实开发中，我们往往会使用 数据库作为数据源进行认证操作。 Realm 负责连接数据源并进行具体 认证，它有一个子类 JdbcRealm ，该类可以自动连接数据库认证。

     1、创建数据表

    1. CREATE TABLE `users`  (
    2.   `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT
    3. NULL,
    4.   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT
    5. NULL
    6. ) ENGINE = InnoDB CHARACTER SET = utf8
    7. COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    8. INSERT INTO `users` VALUES ('bizhn', 'bizhn');

    2、编写登录控制器方法

    1. @RequestMapping("/user/login2")
    2. public String login2(String username,String password){
    3.     // 1.获取SecurityManager对象
    4.     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    5.     // 2.为SecurityManager对象设置Realm
    6.     JdbcRealm jdbcRealm = new JdbcRealm();
    7.     jdbcRealm.setDataSource(dataSource);
    8.     securityManager.setRealm(jdbcRealm);
    9.     // 3.将SecurityManager对象设置到运行环境中
    10.     SecurityUtils.setSecurityManager(securityManager);
    11.     // 4.获取Subject对象
    12.     Subject subject = SecurityUtils.getSubject();
    13.     // 5.将前端传来的用户名密码封装为Shiro提供的身份对象
    14.     UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    15.     try {
    16.         // 6.shiro认证
    17.         subject.login(token);
    18.         // 7.认证通过跳转到主页面
    19.         return "main";
    20.    }catch (AuthenticationException e){
    21.         // 8.认证不通过跳转到失败页面
    22.         return "fail";
    23.    }
    24. }

    3、启动项目，访问登录页http://localhost/login，测试登录功能。

    Shiro认证_将Shiro对象交给容器管理 

     之前的案例中，所有关于Shiro的对象都是自己创建的。我们在 SpringBoot中使用Shiro，就可以将Shiro的对象交给容器管理，简 化业务代码。

    1、创建Shiro配置类

    1. @Configuration
    2. public class ShiroConfig {
    3.     // SecurityManager对象
    4.     @Bean
    5.     public DefaultWebSecurityManager getDefaultWebSecurityManager(JdbcRealm jdbcRealm){
    6.         DefaultWebSecurityManager defaultSecurityManager=new DefaultWebSecurityManager();
    7.         defaultSecurityManager.setRealm(jdbcRealm);
    8.         return defaultSecurityManager;
    9.    }
    10.     // JdbcRealm
    11.     @Bean
    12.     public JdbcRealm getJdbcRealm(DataSource dataSource) {
    13.         JdbcRealm jdbcRealm = new JdbcRealm();
    14.         jdbcRealm.setDataSource(dataSource);
    15.         return jdbcRealm;
    16.    }
    17. }

    2、创建 UserService.java

    1. @Service
    2. public class UsersService {
    3. @Autowired
    4.     private DefaultWebSecurityManager securityManager;
    5.     public void userLogin(String username,String password) throws AuthenticationException {
    6.         // 1.将SecurityManager对象设置到运行环境中
    7.       SecurityUtils.setSecurityManager(securityManager);
    8.         // 2.获取Subject对象
    9.         Subject subject = SecurityUtils.getSubject();
    10.         // 3.将前端传来的用户名密码封装为Shiro提供的身份对象
    11.         UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    12.         // 4.Shiro认证
    13.         subject.login(token);
    14.    }
    15. }

    3、编写登录控制器方法

    1. @RequestMapping("/user/login2")
    2. public String login2(String
    3. username,String password){
    4.     try {
    5.        usersService.userLogin(username,password);
    6.         return "main";
    7.    }catch (AuthenticationException e){
    8.         return "fail";
    9.    }
    10. }

    4、启动项目，访问登录页http://localhost/login，测试登录功能。

    Shiro认证_自定义Realm 

     使用 JdbcRealm 认证时，数据库表名、字段名、认证逻辑都不能改变， 我们可以自定义Realm进行更灵活的认证。

    1、准备数据表

    1. CREATE TABLE `users`  (
    2.   `uid` int(11) NOT NULL AUTO_INCREMENT,
    3.   `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
    4.   `password` varchar(255) CHARACTER SET
    5. utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
    6.   PRIMARY KEY (`uid`) USING BTREE
    7. ) ENGINE = InnoDB CHARACTER SET = utf8
    8. COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    9. INSERT INTO `users` VALUES (1, 'bizan','123');

    2、编写实体类

    1. @Data
    2. public class Users {
    3.     private Integer uid;
    4.     private String username;
    5.     private String password;
    6. }

    3、编写mapper接口

    public interface UsersMapper extends BaseMapper { }

    4、在启动类加载mapper接口

    1. @SpringBootApplication
    2. @MapperScan("com.itbaizhan.myshiro1.mapper")
    3. public class Myshiro1Application {
    4.     public static void main(String[] args)
    5.    {
    6.       SpringApplication.run(Myshiro1Application.class, args);
    7.    }
    8. }

    5、编写自定义Realm类

    1. public class MyRealm extends
    2. AuthorizingRealm {
    3.     @Autowired
    4.     private UserInfoMapper userInfoMapper;
    5.     // 自定义认证方法
    6.     @Override
    7.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    8.         // 1.获取用户输入的用户名
    9.         UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    10.         String username = token.getUsername();
    11.         // 2.根据用户名查询用户
    12.         QueryWrapper wrapper = new QueryWrapper().eq("username",username);
    13.         Users users = usersMapper.selectOne(wrapper);
    14.         // 3.将查询到的用户封装为认证信息
    15.         if (users == null) {
    16.             throw new UnknownAccountException("账户不存在");
    17.        }
    18.         /**
    19.          * 参数1：用户
    20.          * 参数2：密码
    21.          * 参数3：Realm名
    22.          */
    23.         return new SimpleAuthenticationInfo(users,users.getPassword(),"myRealm");
    24.    }
    25.     // 自定义授权方法
    26.     @Override
    27.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    28.         return null;
    29.    }
    30. }

    6、将自定义Realm放入SecurityManager对象中

    1. @Configuration
    2. public class ShiroConfig {
    3.     // 自定义Realm
    4.     @Bean
    5.     public MyRealm myRealm(){
    6.         return new MyRealm();
    7.    }
    8.     
    9.     // SecurityManager对象
    10.     @Bean
    11.     public DefaultWebSecurityManager getDefaultWebSecurityManager(MyRealm myRealm){
    12.         DefaultWebSecurityManager defaultSecurityManager=new DefaultWebSecurityManager();
    13.         // 自定义Realm放入SecurityManager中
    14.        defaultSecurityManager.setRealm(myRealm);
    15.        return defaultSecurityManager;
    16.    }
    17. }

    7、无需修改Service和Controller

    8、启动项目，访问登录页http://localhost/login，测试登录功能。

    Shiro认证_多Realm认证 

     在实际开发中，我们的认证逻辑可能不止一种，例如：

    1、系统支持用户名密码认证，也支持扫描二维码认证；

    2、在系统中有管理员和普通用户两张表，管理员和普通用户的认证逻辑是不一样的；

    3、用户数据量庞大，分别存在不同的数据库中，认证时需要连接多个数据源。

    以上情况都需要配置多个Realm进行认证，我们以第二种情况举 例，讲解Shiro中多Realm认证的写法：

    1、在数据库创建admin表

    1. CREATE TABLE `admin`  (
    2.   `id` int(11) NOT NULL,
    3.   `name` varchar(255) CHARACTER SET utf8
    4. COLLATE utf8_general_ci NULL DEFAULT NULL,
    5.   `password` varchar(255) CHARACTER SET
    6. utf8 COLLATE utf8_general_ci NULL DEFAULT
    7. NULL,
    8.   PRIMARY KEY (`id`) USING BTREE
    9. ) ENGINE = InnoDB CHARACTER SET = utf8
    10. COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    11. INSERT INTO `admin` VALUES (1, 'bizan','123');
    12. INSERT INTO `admin` VALUES (2, 'xtzb','456');

    2、创建Admin实体类和AdminMapper接口

    1. @Data
    2. public class Admin {
    3.     private Integer id;
    4.     private String name;
    5.     private String password;
    6. }
    7. public interface AdminMapper extends BaseMapper {}

    3、MyRealm 认证User用户， MyRealm2 认证Admin用户

    1. public class MyRealm2 extends AuthorizingRealm {
    2. @Autowired
    3.     private AdminMapper adminMapper;
    4.     // 自定义认证方法
    5.     @Override
    6.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    7.         // 1.获取输入的管理员名
    8.         UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    9.         String username = token.getUsername();
    10.         // 2.根据管理员名查询管理员
    11.         QueryWrapper wrapper = new QueryWrapper().eq("name",username);
    12.         Admin admin =adminMapper.selectOne(wrapper);
    13.         // 3.将查询到的管理员封装为认证信息
    14.         if (admin == null) {
    15.             throw new UnknownAccountException("账户不存在");
    16.        }
    17.         /**
    18.          * 参数1：管理员
    19.          * 参数2：密码
    20.          * 参数3：Realm名
    21.          */
    22.         return new SimpleAuthenticationInfo(admin,
    23.                 admin.getPassword(),
    24.                 "myRealm2");
    25.    }
    26.     // 自定义授权方法
    27.     @Override
    28.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    29.         return null;
    30.    }
    31. }

    4、在SecurityManager中配置Realm

    1. // Realm
    2. @Bean
    3. public MyRealm getMyRealm() {
    4.     return new MyRealm();
    5. }
    6. @Bean
    7. public MyRealm2 getMyRealm2() {
    8.     return new MyRealm2();
    9. }
    10. // SecurityManager对象
    11. @Bean
    12. public DefaultWebSecurityManager
    13. getDefaultWebSecurityManager(MyRealm realm, MyRealm2 realm2){
    14.     DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager();
    15.     // Realm放入SecurityManager中
    16.     List realms = new ArrayList();
    17.     realms.add(realm);
    18.     realms.add(realm2);
    19.     defaultSecurityManager.setRealms(realms);
    20.     return defaultSecurityManager;
    21. }

    5、使用 bizan：123 和 xtzb：456 测试认证效果

     Shiro认证_多Realm认证策略

     如果有多个Realm，怎样才能认证成功，这就是认证策略。认证策 略主要使用的是 AuthenticationStrategy 接口，这个接口有三个实现类：

    1. // Realm管理者
    2. @Bean
    3. public ModularRealmAuthenticator modularRealmAuthenticator(){
    4.     ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
    5.     //设置认证策略
    6.     modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
    7.     return modularRealmAuthenticator;
    8. }
    9. // SecurityManager对象
    10. @Bean
    11. public DefaultWebSecurityManager getDefaultWebSecurityManager(MyRealm realm,MyRealm2 realm2){
    12.     DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager();
    13.     // 设置Realm管理者（需要在设置Realm之前）
    14.     defaultSecurityManager.setAuthenticator(modularRealmAuthenticator());
    15.     List realms = new ArrayList();
    16.     realms.add(realm);
    17.     realms.add(realm2);
    18.     defaultSecurityManager.setRealms(realms);
    19.     return defaultSecurityManager;
    20. }

    在 ModularRealmAuthenticator 中的 doMultiRealmAuthentication 方法中添加断点可以 查看认证通过信息。

    Shiro认证_异常处理

     当Shiro认证失败后，会抛出 AuthorizationException 异常。该异常的子类分 别代表不同的认证失败原因，我们可以通过捕捉它们确定认证失败原因。

    1、DisabledAccountException：账户失效

    2、ConcurrentAccessException：竞争次数过多

    3、ExcessiveAttemptsException：尝试次数过多

    4、UnknownAccountException：用户名不正确

    5、IncorrectCredentialsException：凭证（密码）不正确

    6、ExpiredCredentialsException：凭证过期

    我们一般在Controller中处理认证异常：

    1. @RequestMapping("/user/login2")
    2. public String login(String username, String password) {
    3.     try {
    4.         usersService.userLogin(username, password);
    5.         return "main";
    6.    } catch (DisabledAccountException e) {
    7.         System.out.println("账户失效");
    8.         return "fail";
    9.    } catch (ConcurrentAccessException e) {
    10.         System.out.println("竞争次数过多");
    11.         return "fail";
    12.    } catch (ExcessiveAttemptsException e) {
    13.         System.out.println("尝试次数过多");
    14.         return "fail";
    15.    } catch (UnknownAccountException e) {
    16.         System.out.println("用户名不正确");
    17.         return "fail";
    18.    } catch (IncorrectCredentialsException e) {
    19.         System.out.println("密码不正确");
    20.         return "fail";
    21.    } catch (ExpiredCredentialsException e)
    22. {
    23.         System.out.println("凭证过期");
    24.         return "fail";
    25.    }
    26. }

    注： 如果将异常信息提示给用户，尽量把异常信息表示的婉转一 些。比如不管用户名还是密码错误，都提示用户名或密码错误，这样有助于提升代码的安全性。

     Shiro认证_散列算法

    散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，适 合于对密码进行加密。比如密码 admin ，产生的散列值是 21232f297a57a5a743894a0e4a801fc3 ，但在md5解密网站很容易的通过散列值 得到密码 admin 。所以在加密时我们可以加一些只有系统知道的干扰 数据，这些干扰数据称之为“盐”，并且可以进行多次加密，这样生 成的散列值相对来说更难破解。

     Shiro支持的散列算法：

    Md2Hash、Md5Hash、Sha1Hash、Sha256Hash、 Sha384Hash、Sha512Hash

    1. @SpringBootTest
    2. public class Md5Test {
    3.     @Test
    4.     public void testMd5() {
    5.         //使用MD5加密
    6.         Md5Hash result1 = new Md5Hash("123");
    7.         System.out.println("md5加密后的结果：" + result1);
    8.         //加盐后加密,加密5次
    9.         Md5Hash result2 = new Md5Hash("123","sxt",5);
    10.         System.out.println("md5加盐加密后的结果：" + result2);
    11.    }
    12. }

    接下来我们在项目中对密码进行加密：

    1、修改数据库和实体类，添加盐字段，并修改数据库用户密码为加盐加密后的数据。

    1. @Data
    2. public class Users{
    3.     private Integer uid;
    4.     private String username;
    5.     private String password;
    6.     private String salt;
    7. }

    2、修改自定义Realm

    1. @Component
    2. public class MyRealm extends AuthorizingRealm {
    3.     @Autowired
    4.     private UserInfoMapper userInfoMapper;
    5.     // 自定义认证方法
    6.     @Override
    7.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    8.         // 1.获取用户输入的用户名
    9.         UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    10.         String username = token.getUsername();
    11.         // 2.根据用户名查询用户
    12.         QueryWrapper wrapper = new QueryWrapper().eq("username",username);
    13.         Users users = usersMapper.selectOne(wrapper);
    14.         // 3.将查询到的用户封装为认证信息
    15.         if (users == null) {
    16.             throw new UnknownAccountException("账户不存在");
    17.        }
    18.         /**
    19.          * 参数1：用户
    20.          * 参数2：密码
    21.          * 参数3：盐
    22.          * 参数4：Realm名
    23.          */
    24.         return new SimpleAuthenticationInfo(users,
    25.                 users.getPassword(),
    26.                 ByteSource.Util.bytes(users.getSalt()),
    27.                 "myRealm");
    28.    }
    29.     // 自定义授权方法
    30.     @Override
    31.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    32.         return null;
    33.    }
    34. }

    3、在注册自定义Realm时添加加密算法

    1. // 配置加密算法
    2. @Bean
    3. public HashedCredentialsMatcher hashedCredentialsMatcher(){
    4.     HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
    5.   //加密算法
    6.   hashedCredentialsMatcher.setHashAlgorithmName("md5");
    7.     //加密的次数
    8.   hashedCredentialsMatcher.setHashIterations(5);
    9.     return hashedCredentialsMatcher;
    10. }
    11. // Realm
    12. @Bean
    13. public MyRealm getMyRealm(HashedCredentialsMatcher hashedCredentialsMatcher) {
    14.     MyRealm myRealm = new MyRealm();
    15.    // 设置加密算法
    16.    myRealm.setCredentialsMatcher(hashedCredentialsMatcher);
    17.     return myRealm;
    18. }

    4、启动项目，访问登录页http://localhost/login，测试登录功能。

    Shiro认证_过滤器 

     在以上案例中，虽然有认证功能，但即使没有登录也可以访问系统 资源。如果要配置认证后才能访问资源，就需要使用过滤器拦截请 求。Shiro内置了很多过滤器：

     过滤器工厂配置过滤器链：

    1. // 配置过滤器
    2. @Bean
    3. public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
    4.     // 1.创建过滤器工厂
    5.     ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
    6.     // 2.过滤器工厂设置SecurityManager
    7.     filterFactory.setSecurityManager(securityManager);
    8.     // 3.设置shiro的拦截规则
    9.     Map filterMap=new HashMap<>();
    10.     // 不拦截的资源
    11.     filterMap.put("/login.html","anon");
    12.     filterMap.put("/fail.html","anon");
    13.     filterMap.put("/user/login","anon");
    14.     filterMap.put("/css/**","anon");
    15.     // 其余资源都需要用户认证
    16.     filterMap.put("/**","authc");
    17.    // 4.将拦截规则设置给过滤器工厂
    18.     filterFactory.setFilterChainDefinitionMap(filterMap);
    19.     // 5.登录页面
    20.     filterFactory.setLoginUrl("/login.html");
    21.     return filterFactory;
    22. }

    Shiro认证_获取认证数据

     用户认证通过后，有时我们需要获取用户信息，比如在网站顶部显 示：欢迎您，XXX。获取用户信息的写法如下：

    1. @RequestMapping("/user/getUsername")
    2. @ResponseBody
    3. public String getUsername(){
    4.     Subject subject = SecurityUtils.getSubject();
    5.     // 获取认证数据
    6.     Users users = (Users)subject.getPrincipal();
    7.     return users.getUsername();
    8. }

    Shiro认证_Shiro会话

     Shiro提供了完整的企业级会话管理功能，不依赖于Web容器，不管 JavaSE还是JavaEE环境都可以使用。

    1. // 使用Shiro提供的会话对象
    2. @RequestMapping("/user/session")
    3. @ResponseBody
    4. public void session(){
    5.     // 1.获取Subject
    6.     Subject subject = SecurityUtils.getSubject();
    7.     // 2.获取会话
    8.     Session session = subject.getSession();
    9.     // 会话id
    10.     System.out.println("会话id:"+session.getId());
    11.     // 会话的主机地址
    12.     System.out.println("会话的主机地址:"+session.getHost());
    13.     // 设置会话过期时间
    14.     session.setTimeout(1000*10);
    15.     // 获取会话过期时间
    16.     System.out.println("会话过期时间:"+session.getTimeout());
    17.     // 会话开始时间
    18.     System.out.println("会话开始时间:"+session.getStartTimestamp());
    19.     // 会话最后访问时间
    20.     System.out.println("会话最后访问时间:"+session.getLastAccessTime());
    21.     // 会话设置数据
    22.     session.setAttribute("name","百战不败");
    23. }
    24. @RequestMapping("/user/getSession")
    25. @ResponseBody
    26. public void getSession(){
    27.     Subject subject = SecurityUtils.getSubject();
    28.     Session session = subject.getSession();
    29.     System.out.println(session.getAttribute("name"));
    30. }

    Shiro认证_会话管理器

    Shiro中提供了会话管理器，可以对会话对象进行配置和监听，用法如下：

    1、创建会话监听器

    1. @Component
    2. public class MySessionListener implements SessionListener {
    3.     //会话创建时触发
    4.     @Override
    5.     public void onStart(Session session) {
    6.         System.out.println("会话创建：" + session.getId());
    7.    }
    8.     //会话过期时触发
    9.     @Override
    10.     public void onExpiration(Session session) {
    11.         System.out.println("会话过期：" + session.getId());
    12.    }
    13.     //退出/会话过期时触发
    14.     @Override
    15.     public void onStop(Session session) {
    16.        System.out.println("会话停止：" + session.getId());
    17.    }
    18. }

    2、在会话管理器中配置会话监听器

    1. // 会话管理器
    2. @Bean
    3. public SessionManager
    4. sessionManager(MySessionListener sessionListener) {
    5.     // 创建会话管理器
    6.     DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    7.     // 创建会话监听器集合
    8.     List listeners = new ArrayList();
    9.     listeners.add(sessionListener);
    10.     // 将监听器集合设置到会话管理器中
    11.     sessionManager.setSessionListeners(listeners);
    12.     // 全局会话超时时间（单位毫秒），默认30分钟,设置为5秒
    13.     sessionManager.setGlobalSessionTimeout(5*1000);
    14.     // 是否开启删除无效的session对象，默认为true
    15.     sessionManager.setDeleteInvalidSessions(true);
    16.     // 是否开启定时调度器进行检测过期session，默认为true
    17.     sessionManager.setSessionValidationSchedulerEnabled(true);
    18.     return sessionManager;
    19. }

    3、在SecurityManager中配置会话管理器

    1. @Bean
    2. public DefaultWebSecurityManager securityManager(MyRealm myRealm,MyRealm2
    3. myRealm2,SessionManager sessionManager){
    4.     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    5.     // 自定义Realm放入SecurityManager中
    6.     // securityManager.setRealm(myRealm);
    7.     // 设置Realm管理者(需要设置在Realm之前)
    8.     securityManager.setAuthenticator(modularRealmAuthenticator());
    9.     List realms = new ArrayList();
    10.     realms.add(myRealm);
    11.     //realms.add(myRealm2);
    12.     securityManager.setRealms(realms);
    13.     securityManager.setSessionManager(sessionManager);
    14.     return securityManager;
    15. }

    Shiro认证_退出登录 

    在系统中一般都有退出登录的操作。退出登录后Shiro会销毁会话和 认证数据。在Shrio中，退出登录的写法如下：

    1、编写退出登录控制器

    1. @RequestMapping("/user/logout")
    2. public String logout(){
    3.     Subject subject = SecurityUtils.getSubject();
    4.     // 退出登录
    5.     subject.logout();
    6.     // 退出后跳转到登录页
    7.     return "redirect:/login";
    8. }

    2、在主页面添加退出登录按钮

    1. html>
    2. <html>
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>主页面title>
    6. head>
    7. <body>
    8.   <h1>主页面h1>
    9.   <h2><a href="/user/logout">退出登录a>h2>
    10. body>
    11. html>

    Shiro认证_Remember Me 

    Remember Me为“记住我”功能，即登录成功后，下次访问系统时无 需重新登录。当使用“记住我”功能登录后，Shiro会在浏览器Cookie 中保存序列化后的认证数据。之后浏览器访问项目时会携带该 Cookie数据，这样不登录也可以完成认证。

    当然，为了安全起见，并不是所有资源都可以通过“记住我”访问。 比如在电商系统中，查询商品等操作可以不登录，但是支付时往往 需要重新登录，Shiro支持配置什么资源可以通过“记住我”访问。

     实现“记住我”功能的写法如下：

    1、序列化所有实体类

    1. @Data
    2. public class Users implements Serializable
    3. {
    4.     private Integer uid;
    5.     private String username;
    6.     private String password;
    7.     private String salt;
    8. }

    2、配置Cookie生成器和记住我管理器

    1. // Cookie生成器
    2. @Bean
    3. public SimpleCookie simpleCookie() {
    4.     SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
    5.     // Cookie有效时间，单位：秒
    6.     simpleCookie.setMaxAge(20);
    7.     return simpleCookie;
    8. }
    9. // 记住我管理器
    10. @Bean
    11. public CookieRememberMeManager cookieRememberMeManager(SimpleCookie simpleCookie) {
    12.     CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
    13.     // Cookie生成器
    14.     cookieRememberMeManager.setCookie(simpleCookie);
    15.     // Cookie加密的密钥
    16.     cookieRememberMeManager.setCipherKey(Base64.decode("6ZmI6I2j3Y+R1aSn5BOlAA=="));
    17.     return cookieRememberMeManager;
    18. }
    19. @Bean
    20. public DefaultWebSecurityManager securityManager(MyRealm myRealm,
    21.                                           
    22.       MyRealm2 myRealm2,SessionManager sessionManager,
    23.                                           
    24.      CookieRememberMeManager rememberMeManager){
    25.      DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    26.     // 自定义Realm放入SecurityManager中
    27.     // securityManager.setRealm(myRealm);
    28.     // 设置Realm管理者(需要设置在Realm之前)
    29.     securityManager.setAuthenticator(modularRealmAuthenticator());
    30.     List realms = new ArrayList();
    31.     realms.add(myRealm);
    32.     //realms.add(myRealm2);
    33.     securityManager.setRealms(realms);
    34.     securityManager.setSessionManager(sessionManager);
    35.     securityManager.setRememberMeManager(rememberMeManager);
    36.     return securityManager;
    37. }

    3、修改登录表单

    1. <form class="form" action="/user/login" method="post">
    2.     <input type="text" placeholder="用户名" name="username">
    3.     <input type="password" placeholder="密码" name="password">
    4.     <input type="checkbox" name="rememberMe" value="on">记住我<br>
    5.     <button type="submit" id="loginbutton">登录button>
    6. form>

    4、修改登录控制器

    1. @RequestMapping("/user/login")
    2. public String login(String username,String password,String rememberMe) {
    3.     try {
    4.         usersService.userLogin(username,password,rememberMe);
    5.         return "main";
    6.    } catch (DisabledAccountException e) {
    7.         System.out.println("账户失效");
    8.         return "fail";
    9.    } catch (ConcurrentAccessException e){
    10.         System.out.println("竞争次数过多");
    11.         return "fail";
    12.    } catch (ExcessiveAttemptsException e){
    13.         System.out.println("尝试次数过多");
    14.         return "fail";
    15.    } catch (UnknownAccountException e) {
    16.         System.out.println("用户名不正确");
    17.         return "fail";
    18.    } catch (IncorrectCredentialsException e) {
    19.         System.out.println("密码不正确");
    20.         return "fail";
    21.    } catch (ExpiredCredentialsException e) {
    22.         System.out.println("凭证过期");
    23.         return "fail";
    24.    }
    25. }

    5、修改登录Service

    1. @Service
    2. public class UsersService {
    3.     @Autowired
    4.     private DefaultWebSecurityManager securityManager;
    5.     public void userLogin(String username,String password,String rememberMe) throws AuthenticationException
    6. {
    7.       SecurityUtils.setSecurityManager(securityManager);
    8.         Subject subject = SecurityUtils.getSubject();
    9.         UsernamePasswordToken token=new UsernamePasswordToken(username,password);
    10.         if (rememberMe != null){
    11.        // 如果用户选择记住我，则生成记住我Cookie
    12.             token.setRememberMe(true);
    13.        }
    14.         subject.login(token);
    15.    }
    16. }

    6、配置过滤器，配置可以通过“记住我”访问的资源。

    1. @Bean
    2. public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
    3.     // 1.创建过滤器工厂
    4.     ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
    5.     // 2.过滤器工厂设置SecurityManager
    6.     filterFactory.setSecurityManager(securityManager);
    7.     // 3.设置shiro的拦截规则
    8.     Map filterMap=new HashMap<>();
    9.     // 不拦截的资源
    10.     filterMap.put("/login.html","anon");
    11.     filterMap.put("/fail.html","anon");
    12.     filterMap.put("/user/login","anon");
    13.     filterMap.put("/static/**","anon");
    14.     // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; 
    15.     //user过滤器表示配置记住我或认证都可以访问
    16.     //filterMap.put("/**","authc");
    17.     filterMap.put("/user/pay","authc");
    18.     filterMap.put("/**", "user");
    19.     // 4.将拦截规则设置给过滤器工厂
    20.     filterFactory.setFilterChainDefinitionMap(filterMap);
    21.     // 5.登录页面
    22.     filterFactory.setLoginUrl("/login.html");
    23.     return filterFactory;
    24. }

    7、编写支付控制器

    1. // 支付
    2. @RequestMapping("/user/pay")
    3. @ResponseBody
    4. public String pay(){
    5.     return "支付功能";
    6. }

     Shiro授权_权限表设计

    授权即认证通过后，系统给用户赋予一定的权限，用户只能根据权 限访问系统中的某些资源。所以在数据库中，用户需要和权限关 联。除了用户表和权限表，还需要创建角色表，他们之间的关系如下：

     用户角色，角色权限都是多对多关系，即一个用户拥有多个角色， 一个角色拥有多个权限。如：张三拥有总经理和股东的角色，而总 经理拥有查询工资、查询报表的权限；股东拥有查寻股权的权限， 这样张三就拥有了查询工资、查询报表、查询股权的权限。

    接下来我们创建除users外的其余表：

    1. CREATE TABLE `role`  (
    2.   `rid` int(11) NOT NULL AUTO_INCREMENT,
    3.   `roleName` varchar(255) CHARACTER SET utf8
    4. COLLATE utf8_general_ci NULL DEFAULT NULL,
    5.   `roleDesc` varchar(255) CHARACTER SET utf8
    6. COLLATE utf8_general_ci NULL DEFAULT NULL,
    7.   PRIMARY KEY (`rid`) USING BTREE
    8. ) ENGINE = InnoDB AUTO_INCREMENT = 4
    9. CHARACTER SET = utf8 COLLATE =
    10. utf8_general_ci ROW_FORMAT = Dynamic;
    11. INSERT INTO `role` VALUES (1,'总经理','管理整个公司');
    12. INSERT INTO `role` VALUES (2,'股东','参与公司决策');
    13. INSERT INTO `role` VALUES (3,'财务','管理公司资产');
    14. CREATE TABLE `permission`  (
    15.   `pid` int(11) NOT NULL AUTO_INCREMENT,
    16. `permissionName` varchar(255) CHARACTER
    17. SET utf8 COLLATE utf8_general_ci NULL
    18. DEFAULT NULL,
    19.   `url` varchar(255) CHARACTER SET utf8
    20. COLLATE utf8_general_ci NULL DEFAULT NULL,
    21.   PRIMARY KEY (`pid`) USING BTREE
    22. ) ENGINE = InnoDB AUTO_INCREMENT = 4
    23. CHARACTER SET = utf8 COLLATE =
    24. utf8_general_ci ROW_FORMAT = Dynamic;
    25. INSERT INTO `permission` VALUES (1,'查询报表', '/reportform/find');
    26. INSERT INTO `permission` VALUES (2,'查询工资', '/salary/find');
    27. INSERT INTO `permission` VALUES (3,'查询税务', '/tax/find');
    28. CREATE TABLE `users_role`  (
    29.   `uid` int(255) NOT NULL,
    30.   `rid` int(11) NOT NULL,
    31.   PRIMARY KEY (`uid`, `rid`) USING BTREE,
    32.   INDEX `rid`(`rid`) USING BTREE,
    33.   CONSTRAINT `users_role_ibfk_1` FOREIGN KEY
    34. (`uid`) REFERENCES `users` (`uid`) ON DELETE
    35. RESTRICT ON UPDATE RESTRICT,
    36.   CONSTRAINT `users_role_ibfk_2` FOREIGN KEY
    37. (`rid`) REFERENCES `role` (`rid`) ON DELETE
    38. RESTRICT ON UPDATE RESTRICT
    39. ) ENGINE = InnoDB CHARACTER SET = utf8
    40. COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    41. INSERT INTO `users_role` VALUES (1, 2);
    42. INSERT INTO `users_role` VALUES (1, 3);
    43. CREATE TABLE `role_permission`  (
    44.   `rid` int(11) NOT NULL,
    45.   `pid` int(11) NOT NULL,
    46.   PRIMARY KEY (`rid`, `pid`) USING BTREE,
    47.   INDEX `pid`(`pid`) USING BTREE,
    48.   CONSTRAINT `role_permission_ibfk_1`
    49. FOREIGN KEY (`rid`) REFERENCES `role`
    50. (`rid`) ON DELETE RESTRICT ON UPDATE
    51. RESTRICT,
    52.   CONSTRAINT `role_permission_ibfk_2`
    53. FOREIGN KEY (`pid`) REFERENCES `permission`
    54. (`pid`) ON DELETE RESTRICT ON UPDATE
    55. RESTRICT ) ENGINE = InnoDB CHARACTER SET = utf8
    56. COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    57. INSERT INTO `role_permission` VALUES (1, 1);
    58. INSERT INTO `role_permission` VALUES (2, 1);
    59. INSERT INTO `role_permission` VALUES (1, 2);
    60. INSERT INTO `role_permission` VALUES (3, 2);
    61. INSERT INTO `role_permission` VALUES (1, 3);
    62. INSERT INTO `role_permission` VALUES (2, 3);

    Shiro授权_数据库查询权限

    在认证后进行授权需要根据用户id查询到用户的权限，写法如下：

    1、编写用户、角色、权限实体类

    1. @Data
    2. public class Users implements Serializable
    3. {
    4.     private Integer uid;
    5.     private String username;
    6.     private String password;
    7.     private String salt;
    8. }
    9. // 角色
    10. @Data
    11. public class Role implements Serializable{
    12.     private Integer rid;
    13.     private String roleName;
    14.     private String roleDesc;
    15. }
    16. // 权限
    17. @Data
    18. public class Permission implements Serializable{
    19.     private Integer pid;
    20.     private String permissionName;
    21.     private String url;
    22. }

    2、修改UsersMapper接口

    1. // 根据用户id查询权限
    2. List findPermissionById(Integer id);

    3、在resources目录中编写UsersMapper的映射文件

    1. "1.0" encoding="UTF-8"?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.itbaizhan.myshiro1.mapper.UsersMapper">
    6.     <select id="findPermissionById" resultType="com.itbaizhan.myshiro1.domain.Permission">
    7.        SELECT DISTINCT permission.pid,permission.permissionName,permission.url FROM
    8.            users
    9.                LEFT JOIN users_role on users.uid = users_role.uid
    10.                LEFT JOIN role on users_role.rid = role.rid
    11.                LEFT JOIN role_permission on role.rid = role_permission.rid
    12.                LEFT JOIN permission on role_permission.pid = permission.pid
    13.        where users.uid = #{uid}
    14.     select>
    15. mapper>

    4、测试方法

    1. @SpringBootTest
    2. public class UserMapperTest {
    3.     @Autowired
    4.     private UsersMapper usersMapper;
    5.     @Test
    6.     public void testFindPermissionById(){
    7.         List permissions = usersMapper.findPermissionById(1);
    8.         permissions.forEach(System.out::println);
    9.    }
    10. }

     Shiro授权_在Realm进行授权

     在自定义Realm中可以自定义授权方法：

    1. // 自定义授权方法
    2. @Override
    3. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    4.     //1.拿到用户认证信息
    5.     Users users = (Users) principalCollection.getPrimaryPrincipal();
    6.     //2.从数据库中查询权限
    7.     List permissions = usersMapper.findPermissionById(users.getUid());
    8.     //3.遍历权限对象，将所有权限名交给Shiro管理
    9.     SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    10.     for (Permission permission : permissions) {
    11.          authorizationInfo.addStringPermission(permission.getUrl());
    12.    }
    13.     return authorizationInfo;
    14. }

    Shiro授权_过滤器配置鉴权

     Shiro可以根据用户拥有的权限，控制具体资源的访问，这一过程称 为鉴权。在Shiro中，可以通过过滤器进行鉴权配置：

    1. // 配置过滤器
    2. @Bean
    3. public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
    4.     // 1.创建过滤器工厂
    5.     ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
    6.     // 2.过滤器工厂设置SecurityManager
    7.    filterFactory.setSecurityManager(securityManager);
    8.     // 3.设置shiro的拦截规则
    9.     Map filterMap=new HashMap<>();
    10.     // 不拦截的资源
    11.     filterMap.put("/login.html","anon");
    12.     filterMap.put("/fail.html","anon");
    13.     filterMap.put("/user/login","anon");
    14.     filterMap.put("/css/**","anon");
    15.     // 鉴权过滤器，要写在/**之前，否则认证都无法通过
    16.     filterMap.put("/reportform/find","perms[/reportform/find]");
    17.     filterMap.put("/salary/find","perms[/salary/find]");
    18.     filterMap.put("/staff/find","perms[/staff/find]");
    19.     // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; 
    20.     //user过滤器表示配置记住我或认证都可以访问
    21.     //filterMap.put("/**","authc");
    22.     filterMap.put("/user/pay","authc");
    23.     filterMap.put("/**", "user");
    24.     
    25.     // 4.将拦截规则设置给过滤器工厂
    26.     filterFactory.setFilterChainDefinitionMap(filterMap);
    27.     // 5.登录页面
    28.     filterFactory.setLoginUrl("/login.html");
    29.     return filterFactory;
    30. }
    31. // 编写测试控制器
    32. @RestController
    33. public class MyController {
    34.     @GetMapping("/reportform/find")
    35.     public String findReportform(){
    36.         return "查询报表";
    37.    }
    38.     @GetMapping("/salary/find")
    39.     public String findSalary(){
    40.         return "查询工资";
    41.    }
    42.     @GetMapping("/staff/find")
    43.     public String findStaff(){
    44.         return "查询员工";
    45.    }
    46. }

    此时如果权限不足会抛出401异常，我们可以自定义权限不足的跳转页面：

    1、编写权限不足页面

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>权限不足title>
    6. head>
    7. <body>
    8.     <h1>您的权限不足，请联系管理员！h1>
    9. body>
    10. html>

    2、配置权限不足的跳转页面

    1. // 配置过滤器
    2. @Bean
    3. public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
    4.     // 1.创建过滤器工厂
    5.     ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
    6.     // 2.过滤器工厂设置SecurityManager
    7.     filterFactory.setSecurityManager(securityManager);
    8.     // 3.设置shiro的拦截规则
    9.     Map filterMap=new HashMap<>();
    10.     // 不拦截的资源
    11.     filterMap.put("/login.html","anon");
    12.     filterMap.put("/fail.html","anon");
    13.     filterMap.put("/noPermission.html","anon");
    14.     filterMap.put("/user/login","anon");
    15.     filterMap.put("/css/**","anon");
    16.     // 鉴权过滤器
    17.     filterMap.put("/reportform/find","perms[/reportform/find]");
    18.     filterMap.put("/salary/find","perms[/salary/find]");
    19.     filterMap.put("/staff/find","perms[/staff/find]");
    20.     // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; 
    21.     //user过滤器表示配置记住我或认证都可以访问
    22.     //filterMap.put("/**","authc");
    23.     filterMap.put("/user/pay","authc");
    24.     filterMap.put("/**", "user");
    25.     //4.将拦截规则设置给过滤器工厂
    26.     filterFactory.setFilterChainDefinitionMap(filterMap);
    27.     // 5.登录页面
    28.     filterFactory.setLoginUrl("/login.html");
    29.     // 6.权限不足访问的页面
    30.     filterFactory.setUnauthorizedUrl("/noPermission.html");
    31.     return filterFactory;
    32. }

    Shiro授权_注解配置鉴权 

     除了过滤器，Shiro也提供了一些鉴权的注解。我们可以使用注解配置鉴权。

    @RequiresGuest：不认证即可访问的资源。

    @RequiresUser：通过登录方式或“记住我”方式认证后可以访问资源。 @RequiresAuthentication：通过登录方式认证后可以访问资 源。

    @RequiresRoles：认证用户拥有特定角色才能访问的资源

    @RequiresPermissions：认证用户拥有特定权限才能访问的资源

    1、在配置类开启Shiro注解 

    1. // 开启shiro注解的支持
    2. @Bean
    3. public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
    4.     AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
    5.     advisor.setSecurityManager(securityManager);
    6.     return advisor;
    7. }
    8. // 开启aop注解支持
    9. @Bean
    10. public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
    11.     DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
    12.     defaultAAP.setProxyTargetClass(true);
    13.     return defaultAAP;
    14. }

    2、在控制器方法上添加鉴权注解

    1. @GetMapping("/test/index")
    2. @RequiresGuest
    3. public String testIndex() {
    4.     return "访问首页";
    5. }
    6. @GetMapping("/test/user")
    7. @RequiresUser
    8. public String testUser() {
    9.     return "用户中心";
    10. }
    11. @GetMapping("/test/pay")
    12. @RequiresAuthentication
    13. public String testPay() {
    14.     return "支付中心";
    15. }
    16. @GetMapping("/tax/find")
    17. @RequiresPermissions("/tax/find")
    18. public String taxFind() {
    19.     return "查询税务";
    20. }
    21. @GetMapping("/address/find")
    22. @RequiresPermissions("/address/find")
    23. public String addressFind() {
    24.     return "查询地址";
    25. }

     Shiro授权_Thymeleaf中进行鉴权

     Shrio可以在一些视图技术中进行控制显示效果。例如Thymeleaf 中，只有认证用户拥有某些权限才会展示一些菜单。

    1、在pom中引入Shiro和Thymeleaf的整合依赖

    1. <dependency>
    2.     <groupId>com.github.theborakompanionigroupId>
    3.     <artifactId>thymeleaf-extrasshiroartifactId>
    4.     <version>2.0.0version>
    5. dependency>

    2、在配置文件中注册ShiroDialect

    1. @Bean
    2. public ShiroDialect shiroDialect(){
    3.     return new ShiroDialect();
    4. }

    3、在Thymeleaf中使用Shiro标签，控制前端的显示内容

    1. html>
    2. <html xmlns:th="http://www.thymeleaf.org"
    3.     xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
    4. <head>
    5.     <meta charset="UTF-8">
    6.     <title>主页面title>
    7. head>
    8. <body>
    9. <h1>主页面h1>
    10. <ul>
    11.     <li shiro:hasPermission="/reportform/find">
    12.       <a href="/reportform/find">查询报表a>li>
    13.    <li shiro:hasPermission="/salary/find">
    14.      <a href="/salary/find">查询工资a>li>
    15.    <li shiro:hasPermission="/staff/find">
    16.      <a href="/staff/find">查询员工a>li>
    17. ul>
    18.     <h2><a href="/user/logout">退出登录a>h2>
    19. body>
    20. html>
    21.

     Shiro授权_缓存

     在Shiro中，每次拦截请求进行鉴权，都会去数据库查询该用户的权 限信息。因为用户的权限信息在短时间内是不可变的，每次查询出 来的数据其实都是重复数据，此时就会非常浪费资源。所以一般我 们会将权限数据放在缓存中进行管理，这样我们就不用每次请求都 查询数据库，提升了系统性能。

    缓存

    缓存即存在于内存中的一块数据。数据库的数据是存储在硬盘上 的，而内存的读写效率要远远的高于数据库。但硬盘中保存的数据 是持久化数据，断电后依然存在；而内存中保存的是临时数据，随 时可能清空。所以我们为了提升系统性能，减少程序和数据库的交 互，会将经常查询但不常改变的，改变后对结果影响不大的数据放 入缓存中。

    Shiro支持多种缓存产品，在课程中我们使用ehcache缓存用户的权限数据。

    ehcache

    ehcache是用来管理缓存的一个工具，其缓存的数据可以放在内存 中，也可以放在硬盘上。ehcache的核心是CacheManager，一切 的ehcache的应用都是从CacheManager开始的。

    1、引入shiro和ehcache整合包

    2. <dependency>
    3.     <groupId>org.apache.shirogroupId>
    4.     <artifactId>shiro-ehcacheartifactId>
    5.     <version>1.9.0version>
    6. dependency>

    2、创建配置文件shiro-ehcache.xml

    1. "1.0" encoding="UTF-8"?>
    2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    4.          updateCheck="false">
    5.     <diskStore path="java.io.tmpdir/Tmp_EhCache"/>
    6.     
    7.     <defaultCache
    8.             maxElementsInMemory="10000"
    9.             timeToIdleSeconds="120"
    10.             timeToLiveSeconds="120"
    11.             diskExpiryThreadIntervalSeconds="120"/>
    12.     
    13.     <cache name="authorizationCache"
    14.            maxEntriesLocalHeap="2000"
    15.            timeToIdleSeconds="0"
    16.            timeToLiveSeconds="0">
    17.     cache>
    18. ehcache>

    3、在配置文件创建CacheManager

    1. // 创建CacheManager
    2. @Bean
    3. public EhCacheManager ehCacheManager() {
    4.     EhCacheManager ehCacheManager = new EhCacheManager();
    5.     ehCacheManager.setCacheManagerConfigFile( "classpath:shiro-ehcache.xml");
    6.     return ehCacheManager;
    7. }

    4、在SecurityManager中配置CacheManager

    1. @Bean
    2. public DefaultWebSecurityManager securityManager(MyRealm myRealm,MyRealm2 myRealm2,
    3.        SessionManager sessionManager, CookieRememberMeManager rememberMeManager,
    4.        EhCacheManager ehCacheManager){
    5.       DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    6.     // 自定义Realm放入SecurityManager中
    7.     // securityManager.setRealm(myRealm);
    8.     // 设置Realm管理者(需要设置在Realm之前)
    9.     securityManager.setAuthenticator(modularRealmAuthenticator());
    10.     List realms = new ArrayList();
    11.     realms.add(myRealm);
    12.     //realms.add(myRealm2);
    13.     securityManager.setRealms(realms);
    14.     securityManager.setSessionManager(sessionManager);
    15.     securityManager.setRememberMeManager(rememberMeManager);
    16.     securityManager.setCacheManager(ehCacheManager);
    17.     return securityManager;
    18. }

    5、启动项目，测试权限缓存。

  • 相关阅读:
    如何在宝塔上面新建虚拟主机
    渗透测试信息收集方法和工具分享
    使用信号量解决并发问题
    高频知识汇总 |【计算机网络】面试题汇总（万字长文通俗易懂）
    flutter系列之:flutter架构什么的,看完这篇文章就全懂了
    ★★[leetCode 42] 接雨水 总结
    学习虚幻C++开发日志——基础案例（持续更新中）
    搭建WAMP网站教程（Windows+Apache+MySQL+PHP）
    字符串资源LoadString 加速键资源TranslateAccelerator、LoadAccelerators
    NotePad++ 在行前/行后添加特殊字符内容方法
  • 原文地址：https://blog.csdn.net/m0_58719994/article/details/128131714