Shiro从入门到实战：入门篇

深藏阁楼爱情的钟 2023-07-19 12:04 13阅读 0赞

# 前言 #

Shiro框架作为Java安全框架，目前是非常火的，目前市面上比较火的Java安全框架就属于`Shiro`和`SpringSecurity`。虽然它的功能没有Spring Security那么强大，但是Shiro的API简单，易于使用。而且相比使用原生的RBAC模型实现认证和授权功能，使用Shiro可以构建更强大的认证授权系统。然后打算写几篇博客记录以及分享Shiro体系知识，达到从认识Shiro到实战的境界。

1.  Shiro从入门到实战：入门篇
2.  Shiro从入门到实战：实战篇
3.  Shiro从入门到实战：进阶篇
4.  Shiro从入门到实战：完结篇

# 1. 学会shiro系列：入门篇 #

1.  Shiro简介
2.  Shiro功能介绍
3.  Shiro外部架构
4.  Shiro内部架构
5.  Shiro身份认证(**登录**)
6.  Shiro登录流程源码分析(重难点)
7.  什么是授权
8.  Shiro授权

# Shiro简介 #

1.  Apache Shiro是一个强大且易用的Java安全框架。Shiro可以非常容易的开发出足够好的认证授权应用，其不仅可以用在JavaSE环境，也可以用在JavaEE 环境。
2.  Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。而且Shiro的API也是非常简单。
3.  Shiro不会去维护用户、维护权限；这些需要我们自己去设计/提供；然后通过相应的接口注入给Shiro即可。

# Shiro功能介绍 #

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

1.  **Authentication**：身份认证/登录，验证用户是不是拥有相应的身份；
2.  **Authorization**：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
3.  **Session Manager**：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；
4.  **Cryptography**：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
5.  **Web Support**：Web支持，可以非常容易的集成到Web环境；
6.  **Caching**：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
7.  **Concurrency**：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
8.  **Testing**：提供测试支持；
9.  **Run As**：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
10. **Remember Me**：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

# Shiro外部架构 #

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

1.  Subject：应用代码直接交互的对象是Subject，也就是说Shiro的对外API核心就是Subject。Subject代表了当前“用户”， 这个用户不一定 是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；与Subject的所有交互都会委托给 SecurityManager； Subject其实是一个门面，SecurityManager才是实际的执行者；
2.  SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且其管理着所有Subject；可以看出它是Shiro的核心，它负责与Shiro的其他组件进行交互，它相当于SpringMVC中DispatcherServlet的角色。
3.  Realm：Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户 进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色/ 权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource。

# Shiro内部架构 #

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

1.  Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”。
2.  SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher，是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。
3.  Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了。
4.  Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能。
5.  Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm。
6.  SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所以呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）。
7.  SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能。
8.  CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能。
9.  Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的。

# Shiro身份认证 #

1.  身份认证就是确认该用户(`正在登录的用户`)是否是应用的合法用户。一般提供身份证，用户名/密码来证明。
2.  在shiro中，用户需要提供`principals` (身份)和`credentials`(凭证)给shiro，以此来认证用户身份。**principals**：身份，即主体的标识属性，可以是任何东西，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/密码/手机号。**credentials**：凭证，即只有主体知道的安全值，如密码/数字证书等。

最常见的`principals`和`credentials`组合就是用户名/密码了。接下来先进行一个基本的身份认证。

1.  环境搭建，使用Maven构建项目，引入以下依赖：
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.3</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.2</version>
        </dependency>
2.  我们在类路径下新建shiro.ini文件，.该文件也可以作为用户、角色、权限的提供者，也就是数据源，这里先提供两个用户信息：zwq=22、zhangsan=18。当JavaWeb集成Shiro之后，数据源就变为数据库(MySQL，Oracle等等)。
    
        [users]
        zwq=22
        zhangsan=18
3.  测试代码， 实现登录与退出。
    
        public class LoginLogout { 
            public static void main(String[] args) { 
                //1.根据.ini配置文件获取SecurityManagerFactory
                IniSecurityManagerFactory factory =
                        new IniSecurityManagerFactory("classpath:shiro.ini");
                //2.使用工厂获取SecurityManager示例
                SecurityManager securityManager = factory.getInstance();
                SecurityUtils.setSecurityManager(securityManager);
                //3.获取主体
                Subject subject = SecurityUtils.getSubject();
                //4.封装token
                UsernamePasswordToken token = new UsernamePasswordToken("zwq", "22");
                //5.执行认证逻辑：登录
                subject.login(token);
                //6.判断是否认证成功
                System.out.println("用户是否认证："+subject.isAuthenticated());
                //7.退出
                subject.logout();
                //8.再次判断是否认证成功
                System.out.println("用户是否认证："+subject.isAuthenticated());
            }
        }
4.  在上面代码中，我们手动封装了token令牌(用户名与密码)，然后主体subject携带令牌进行认证(`subject.login()`)，底层是委托SecurityManager进行认证(`SecurityManager.login()`)，认证是否成功可以调用主体的`isAuthenticated()`方法判断，主体进行退出操作时(`subject.logout()`)，底层也是委托SecurityManager执行退出操作(`SecurityManager.logout()`)。
5.  上面的用户名和密码都是正确的，接下来测试两种情况：  
    `一是用户名正确而密码错误`，这种情况会出现`IncorrectCredentialsException`异常，所以以后出现这个异常就知道是密码错了。
    
        //用户名正确而命名错误
        UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "22");
    
        org.apache.shiro.authc.IncorrectCredentialsException: 
        	Submitted credentials for token [org.apache.shiro.authc.UsernamePasswordToken - zhangsan, rememberMe=false] did not match the expected credentials.
    
    `二是用户名错误而密码正确`，这种情况会出现`UnknownAccountException`异常，所以以后出现这个异常就知道是用户名错了。
    
        //用户名错误而密码正确
        UsernamePasswordToken token = new UsernamePasswordToken("zs", "18");
    
        org.apache.shiro.authc.UnknownAccountException: 
        	Realm [org.apache.shiro.realm.text.IniRealm@7006c658] was unable to find account data for the submitted AuthenticationToken 
        	[org.apache.shiro.authc.UsernamePasswordToken - zs, rememberMe=false].
6.  列举常见的异常及其产生原因。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 3]

# Shiro登录流程源码分析(重难点) #

上面我们学会了使用Shiro编写认证代码，接下来打个断点查看并分析认证源码：

1.  我们在登录操作时打断点，debug运行，程序就停止在断点处，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 4]
2.  我们进入Subject主体的实现类中，subject将登录操作委托给了SecurityManager，参数除了页面传入的token以外还有subject主体，按下F7进入方法内部  
    ![在这里插入图片描述][20200331142546861.png]
3.  进入到SecurityManager实现类中，开始执行认证方法，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 5]
4.  我们发现SecurityManager将认证任务委托给了认证器，由认证器执行认证方法，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 6]
5.  开始执行认证方法，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 7]
6.  我们看到方法里面有一个realms属性，它是干啥的？下面解释Realm是什么：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 8]
7.  Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
8.  上面使用.ini文件存储用户相关信息，以及使用new IniSecurityManagerFactory(“classpath:shiro.ini”)来读取，那么Shiro默认会使用它内部定义好的Realm：IniRealm，查看Realm接口的继承树也可得知：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 9]
9.  回到6步骤，因为只查出一个Realm，所以执行下面方法，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 10]
10. 按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 11]
11. 按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 12]
12. account是AuthenticationInfo接口的实现类，该方法只是返回token携带的用户名。该方法执行完毕，返回到上图方法调用处。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 13]
13. Shiro认证过程是先判断用户名是否正确，然后再去匹配密码，按下F7进入方法内部  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 14]
14. 执行下面方法判断密码是否正确，按下F7进入方法内部![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 15]
15. 这个方法就是把我们刚才取得的那个realm中的密码和我们页面传入的密码比较，如果密码正确就认证成功，如果不正确就抛异常。  
    ![在这里插入图片描述][20200331152101422.png]
16. 上面我们分析了Shiro认证的源码。首先根据用户名判断账号存不存在，存在就去判断密码，不存在就抛异常。如果密码正确，则认证通过，如果不正确，也会抛异常。下图是Shiro官方给出的认证流程图，大致和上面分析的差不多。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 16]

# 什么是授权 #

**授权**，也叫**访问控制**，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。  
不管是使用Shiro框架，还是其他安全框架，都会涉及这几个关键对象：主体、角色、资源、权限。

1.  主体，即访问应用的用户，在Shiro中使用Subject代表该用户。用户只有授权后才允许访问相应的资源。
2.  在应用中用户可以访问的任何东西，比如访问页面、查看/编辑某些数据、访问某个业务方法、导入导出Excel等等都是资源。用户只有授权后才能访问。
3.  安全策略中的原子授权单位，权限表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：  
    访问用户列表页面，查看/新增/修改/删除用户数据（即很多时候都是CRUD（增查改删）式权限控制），导入导出Excel等等。
4.  角色代表了操作集合，可以理解为权限的集合，一般情况下我们会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限。

**Shiro支持三种方式的授权**

1.  编程式：通过写if/else授权代码块完成：
    
        Subject subject = SecurityUtils.getSubject();  
        if(subject.hasRole(“admin”)) {   
            //有权限 
        } else {   
            //无权限 
        }
2.  注解式：通过在执行的Java方法上放置相应的注解完成：
    
        @RequiresRoles("admin")  
        public void deleteUser() {   
            //有admin权限才执行 
        }
3.  JSP/thymeleaf标签：在JSP/thymeleaf页面通过相应的标签完成：
    
        <shiro:hasRole name="admin">  
        <!— 有权限才解析这段HTML代码 —>  
        </shiro:hasRole>

# Shiro授权 #

授权只能在认证成功之后才执行，就像上面说的，如果认证不通过就会报异常，就不可能再执行授权代码了。而且在我们经常做的Web项目中，用户输入用户名和密码进行登录(这就是认证过程)，只有成功登录之后才能进入系统，登录不成功还是会返回登录页面。  
接下来在JavaSE环境下使用Shiro编写代码判断用户是否拥有某些角色。

1.  还是和上面认证一样，在类路径下创建users-roles.ini文件，在其中创建两个用户以及每个用户拥有的角色。  
    **`用户名=密码,角色1,角色2,...`**
    
        [users]
        zwq=22,admin,tester
        zhangsan=18,tester
2.  测试代码，判断用户拥有的角色。下面把认证逻辑代码抽离出来，每次执行授权之前进行认证即可。  
    **boolean hasAllRoles(Collection roleIdentifiers)**：判断用户是否拥有一组权限。是，返回true；不是，返回false。  
    **boolean hasRole(String roleIdentifier)**：判断用户是否拥有某个角色。  
    **boolean\[\] hasRoles(List roleIdentifiers)**：该方法传入一组角色集合，逐个判断是否拥有该角色，有就是true，没有就是false。
    
        public class LoginLogout { 
        
            private static Subject subject;
        
            public static void main(String[] args) { 
            	//认证
                login("classpath:users-roles.ini","zhangsan","18");
                //判断用户是否拥有一组权限。是，返回true；不是，返回false。
                System.out.println(subject.hasAllRoles(Arrays.asList("admin", "tester")));
                //判断用户是否拥有某个权限
                System.out.println(subject.hasRole("tester"));
                //
                boolean[] hasRoles = subject.hasRoles(Arrays.asList("admin", "tester", "boss"));
                for (int i = 0; i < hasRoles.length; i++) { 
                    System.out.println(hasRoles[i]);
                }
            }
        	
        	/** 封装认证逻辑代码 */
            public static void login(String configFile,String username,String password){ 
                //1.根据.ini配置文件获取SecurityManagerFactory
                IniSecurityManagerFactory factory =
                        new IniSecurityManagerFactory(configFile);
                //2.使用工厂获取SecurityManager示例
                SecurityManager securityManager = factory.getInstance();
                SecurityUtils.setSecurityManager(securityManager);
                //3.获取主体
                subject = SecurityUtils.getSubject();
                //4.封装token
                UsernamePasswordToken token = new UsernamePasswordToken(username, password);
                //5.执行认证逻辑：登录
                subject.login(token);
            }
        }
3.  下面再介绍一组判断角色的方法，这些方法和上面方法的作用一模一样，只不过没有返回值，而且在判断是假的时候就把抛异常。  
    void checkRole(String roleIdentifier) throws AuthorizationException;  
    void checkRoles(Collection roleIdentifiers) throws AuthorizationException;  
    void checkRoles(Collection roleIdentifiers) throws AuthorizationException;
    
        public class LoginLogout { 
        		
            private static Subject subject;
        
            public static void main(String[] args) { 
            	//认证
                login("classpath:users-roles.ini","zhangsan","18");
                subject.checkRole("admin");
                subject.checkRoles(Arrays.asList("admin", "tester"));
                subject.checkRoles(Arrays.asList("admin", "tester", "boss"));
            }
        	
        	/** 封装认证逻辑代码 */
            public static void login(String configFile,String username,String password){ 
                //1.根据.ini配置文件获取SecurityManagerFactory
                IniSecurityManagerFactory factory =
                        new IniSecurityManagerFactory(configFile);
                //2.使用工厂获取SecurityManager示例
                SecurityManager securityManager = factory.getInstance();
                SecurityUtils.setSecurityManager(securityManager);
                //3.获取主体
                subject = SecurityUtils.getSubject();
                //4.封装token
                UsernamePasswordToken token = new UsernamePasswordToken(username, password);
                //5.执行认证逻辑：登录
                subject.login(token);
            }
        }

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

1.  上面的校验是基于角色的，是粗粒度的权限校验。接下来介绍细粒度的权限校验：基于权限/资源的校验。重新在类路径下创建users-roles-permissions.ini文件，编写规则：“用户名=密码，角色1，角色2”“角色=权限1，权限2”。
    
        [users]
        zwq=22,admin,tester
        zhangsan=18,tester
        [roles]
        admin=user:insert,user:select,user:update
        tester=user:select,user:delete
2.  测试代码，判断是否拥有权限有如下三个方法：  
    **boolean isPermitted(String permission)**：判断是否拥有某个权限。  
    **boolean isPermittedAll(String… permissions)**：判断是否拥有一组权限。  
    \*\*boolean\[\] isPermitted(String… permissions)\*\*逐个判断每一个权限，拥有该权限就为true，没有就为false。
    
        public class LoginLogout { 
        
            private static Subject subject;
        
            public static void main(String[] args) { 
                login("classpath:users-roles-permissions.ini","zhangsan","18");
                //判断拥有某个权限
                System.out.println(subject.isPermitted("user:delete"));
                //判断拥有一组权限
                System.out.println(subject.isPermittedAll("user:insert", "user:create"));
                boolean[] permitted = subject.isPermitted("user:insert", "user:create");
                for (int i = 0; i < permitted.length; i++) { 
                    System.out.println(permitted[i]);
                }
            }
        
            public static void login(String configFile,String username,String password){ 
                //1.根据.ini配置文件获取SecurityManagerFactory
                IniSecurityManagerFactory factory =
                        new IniSecurityManagerFactory(configFile);
                //2.使用工厂获取SecurityManager示例
                SecurityManager securityManager = factory.getInstance();
                SecurityUtils.setSecurityManager(securityManager);
                //3.获取主体
                subject = SecurityUtils.getSubject();
                //4.封装token
                UsernamePasswordToken token = new UsernamePasswordToken(username, password);
                //5.执行认证逻辑：登录
                subject.login(token);
            }
        }
3.  再介绍一组校验权限的方法，和上面一组方法作用一样，只不过当校验为false的时候，会抛出异常。  
    **void checkPermission(String permission) throws AuthorizationException;**  
    **void checkPermissions(String… permissions) throws AuthorizationException;**
    
        public class LoginLogout { 
        
            private static Subject subject;
        
            public static void main(String[] args) { 
                login("classpath:users-roles-permissions.ini","zhangsan","18");
                //判断拥有某个权限
                subject.checkPermission("user:insert");
                //判断拥有一组权限
                subject.checkPermissions("user:insert", "user:create");
            }
        
            public static void login(String configFile,String username,String password){ 
                //1.根据.ini配置文件获取SecurityManagerFactory
                IniSecurityManagerFactory factory =
                        new IniSecurityManagerFactory(configFile);
                //2.使用工厂获取SecurityManager示例
                SecurityManager securityManager = factory.getInstance();
                SecurityUtils.setSecurityManager(securityManager);
                //3.获取主体
                subject = SecurityUtils.getSubject();
                //4.封装token
                UsernamePasswordToken token = new UsernamePasswordToken(username, password);
                //5.执行认证逻辑：登录
                subject.login(token);
            }
        }

# 总结 #

1.  这篇博文只是对Shiro的入门，没有结合JavaWeb来讲解，让人感觉写的很简单的样子，之后的几篇会使用Spring，SpringBoot来整合Shiro。如果哪里写的不好，也欢迎大家不吝指出。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70]: /images/20230528/1461578b1f034c038acd939425002d1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/b4520c2dd0dd40bdb2e559675d8422f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/6aa3c2ee254943e78a9f260f869e2c38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/138fd6dc1c324989b29127c6dc558067.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 4]: /images/20230528/626680b4981d4b9d82a6ff6e475dfcd1.png
[20200331142546861.png]: /images/20230528/fb96790088bf4737b7ed313902efcbb0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 5]: /images/20230528/4a53c94b6ae44c2aa9b53772deb2ee61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 6]: /images/20230528/5f0cc5c8a15d4b5db6be3e9e3e33a5af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 7]: /images/20230528/aa4d7c7c656b42158f63c25fdea453ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 8]: /images/20230528/d6ade1a462124a7b8685a496393b27ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 9]: /images/20230528/fd2e2e122cbd4c86a3864c16cbad6571.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 10]: /images/20230528/928b110ff26e44238e9e221e93b46ecd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 11]: /images/20230528/4550b2a011db48df8605949f47f907fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 12]: /images/20230528/c4514f297aba4034acddd34612d7fb07.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 13]: /images/20230528/f2b364f092fe42fd8a03c8d4db196cc6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 14]: /images/20230528/f9ed2cb0ed5e440b8ccd715f342992a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 15]: /images/20230528/f10fd68f23eb4f5c8346cca695dc3cef.png
[20200331152101422.png]: /images/20230528/445cd23206454288bc1c71976aed04d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE3NjE2OQ_size_16_color_FFFFFF_t_70 16]: /images/20230528/c9e80f4ac16e40fea68bac1808233d97.png