Shiro从入门到实战：入门篇

前言

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功能介绍

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外部架构

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内部架构

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组合就是用户名/密码了。接下来先进行一个基本的身份认证。

3. 环境搭建，使用Maven构建项目，引入以下依赖：

   <dependency>
       <groupId>junitgroupId>
       <artifactId>junitartifactId>
       <version>4.13version>
       <scope>testscope>
   dependency>
   <dependency>
       <groupId>commons-logginggroupId>
       <artifactId>commons-loggingartifactId>
       <version>1.1.3version>
   dependency>
   
   <dependency>
       <groupId>org.apache.shirogroupId>
       <artifactId>shiro-coreartifactId>
       <version>1.2.2version>
   dependency>
   

4. 我们在类路径下新建shiro.ini文件，.该文件也可以作为用户、角色、权限的提供者，也就是数据源，这里先提供两个用户信息：zwq=22、zhangsan=18。当JavaWeb集成Shiro之后，数据源就变为数据库(MySQL，Oracle等等)。

   [users]
   zwq=22
   zhangsan=18
   

5. 测试代码， 实现登录与退出。

   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());
       }
   }
   

6. 在上面代码中，我们手动封装了token令牌(用户名与密码)，然后主体subject携带令牌进行认证(subject.login())，底层是委托SecurityManager进行认证(SecurityManager.login())，认证是否成功可以调用主体的isAuthenticated()方法判断，主体进行退出操作时(subject.logout())，底层也是委托SecurityManager执行退出操作(SecurityManager.logout())。
7. 上面的用户名和密码都是正确的，接下来测试两种情况：
   一是用户名正确而密码错误，这种情况会出现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].
   

8. 列举常见的异常及其产生原因。
   

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

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

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

什么是授权

授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。
不管是使用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);
       }
   }
   

---

4. 上面的校验是基于角色的，是粗粒度的权限校验。接下来介绍细粒度的权限校验：基于权限/资源的校验。重新在类路径下创建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
   

5. 测试代码，判断是否拥有权限有如下三个方法：
   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);
       }
   }
   

6. 再介绍一组校验权限的方法，和上面一组方法作用一样，只不过当校验为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。如果哪里写的不好，也欢迎大家不吝指出。