[java] Shiro 框架学习（一）

深碍√TFBOYSˉ_ 2022-03-01 04:28 197阅读 0赞

### Shiro 简介 ###

shiro是一个安全框架,可以进行认证、授权、密码加密、会话管理。

与spring Security 一样都是做一个权限的安全框架，但是与Spring Security 相比，在于 Shiro 使用了比较简单易懂易于使用的授权方式。shiro属于轻量级框架，相对于security简单的多，也没有security那么复杂。所以我这里也是简单介绍一下shiro的使用。

### Shiro 三大组件 ###

![format_png][]

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；

SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；

Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

### 主要功能 ###

![format_png 1][]

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

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

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web支持，可以非常容易的集成到Web环境；

Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

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

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

Shiro认证机制

认证就是验证用户身份的过程。在认证过程中，用户需要提交实体信息(Principals)和凭据信息(Credentials)以检验用户是否合法。最常见的“实体/凭证”组合便是“用户名/密码”组合。

### Shiro认证过程  ###

1、收集实体/凭据信息

//Example using most common scenario of username/password pair:  
    UsernamePasswordToken token = new UsernamePasswordToken(username, password);  
    //”Remember Me” built-in:  
    token.setRememberMe(true);

UsernamePasswordToken支持最常见的用户名/密码的认证机制。同时，由于它实现了RememberMeAuthenticationToken接口，我们可以通过令牌设置“记住我”的功能。   
但是，“已记住”和“已认证”是有区别的：   
已记住的用户仅仅是非匿名用户，你可以通过subject.getPrincipals()获取用户信息。但是它并非是完全认证通过的用户，当你访问需要认证用户的功能时，你仍然需要重新提交认证信息。   
这一区别可以参考亚马逊网站，网站会默认记住登录的用户，再次访问网站时，对于非敏感的页面功能，页面上会显示记住的用户信息，但是当你访问网站账户信息时仍然需要再次进行登录认证。

2、提交实体/凭据信息

Subject currentUser = SecurityUtils.getSubject();  
    currentUser.login(token);

收集了实体/凭据信息之后，我们可以通过SecurityUtils工具类，获取当前的用户，然后通过调用login方法提交认证。

3、认证处理

try {  
        currentUser.login(token);  
    } catch ( UnknownAccountException uae ) { ...  
    } catch ( IncorrectCredentialsException ice ) { ...  
    } catch ( LockedAccountException lae ) { ...  
    } catch ( ExcessiveAttemptsException eae ) { ...  
    } ... catch your own ...  
    } catch ( AuthenticationException ae ) {  
        //unexpected error?  
    }

如果login方法执行完毕且没有抛出任何异常信息，那么便认为用户认证通过。之后在应用程序任意地方调用SecurityUtils.getSubject() 都可以获取到当前认证通过的用户实例，使用subject.isAuthenticated()判断用户是否已验证都将返回true.   
相反，如果login方法执行过程中抛出异常，那么将认为认证失败。Shiro有着丰富的层次鲜明的异常类来描述认证失败的原因，如代码示例。

三、认证内部处理机制   
以上，是Shiro认证在应用程序中的处理过程，下面将详细解说Shiro认证的内部处理机制。   
![format_png 2][]

如上图，我们通过Shiro架构图的认证部分，来说明Shiro认证内部的处理顺序：   
1、应用程序构建了一个终端用户认证信息的AuthenticationToken 实例后，调用Subject.login方法。   
2、Sbuject的实例通常是DelegatingSubject类（或子类）的实例对象，在认证开始时，会委托应用程序设置的securityManager实例调用securityManager.login(token)方法。   
3、SecurityManager接受到token(令牌)信息后会委托内置的Authenticator的实例（通常都是ModularRealmAuthenticator类的实例）调用authenticator.authenticate(token). ModularRealmAuthenticator在认证过程中会对设置的一个或多个Realm实例进行适配，它实际上为Shiro提供了一个可拔插的认证机制。   
4、如果在应用程序中配置了多个Realm，ModularRealmAuthenticator会根据配置的AuthenticationStrategy(认证策略)来进行多Realm的认证过程。在Realm被调用后，AuthenticationStrategy将对每一个Realm的结果作出响应。   
注：如果应用程序中仅配置了一个Realm，Realm将被直接调用而无需再配置认证策略。   
5、判断每一个Realm是否支持提交的token，如果支持，Realm将调用getAuthenticationInfo(token); getAuthenticationInfo 方法就是实际认证处理，我们通过覆盖Realm的doGetAuthenticationInfo方法来编写我们自定义的认证处理。

四、使用多个Realm的处理机制：

1、Authenticator   
默认实现是ModularRealmAuthenticator,它既支持单一Realm也支持多个Realm。如果仅配置了一个Realm，ModularRealmAuthenticator 会直接调用该Realm处理认证信息，如果配置了多个Realm，它会根据认证策略来适配Realm，找到合适的Realm执行认证信息。   
自定义Authenticator的配置：

[main]  
    ...  
    authenticator = com.foo.bar.CustomAuthenticator  
    securityManager.authenticator = $authenticator

2、AuthenticationStrategy（认证策略）   
当应用程序配置了多个Realm时，ModularRealmAuthenticator将根据认证策略来判断认证成功或是失败。   
例如，如果只有一个Realm验证成功，而其他Realm验证失败，那么这次认证是否成功呢？如果大多数的Realm验证成功了，认证是否就认为成功呢？或者，一个Realm验证成功后，是否还需要判断其他Realm的结果？认证策略就是根据应用程序的需要对这些问题作出决断。   
认证策略是一个无状态的组件，在认证过程中会经过4次的调用：   
在所有Realm被调用之前  
在调用Realm的getAuthenticationInfo 方法之前  
在调用Realm的getAuthenticationInfo 方法之后  
在所有Realm被调用之后  
认证策略的另外一项工作就是聚合所有Realm的结果信息封装至一个AuthenticationInfo实例中，并将此信息返回，以此作为Subject的身份信息。   
Shiro有3中认证策略的具体实现：

<table> 
 <tbody> 
  <tr> 
   <td>AtLeastOneSuccessfulStrategy</td> 
   <td style="width:517px;">&nbsp;只要有一个（或更多）的Realm验证成功，那么认证将被视为成功</td> 
  </tr> 
  <tr> 
   <td>FirstSuccessfulStrategy&nbsp;&nbsp;</td> 
   <td style="width:517px;">&nbsp;第一个Realm验证成功，整体认证将被视为成功，且后续Realm将被忽略</td> 
  </tr> 
  <tr> 
   <td>AllSuccessfulStrategy&nbsp;&nbsp;</td> 
   <td style="width:517px;">&nbsp;所有Realm成功，认证才视为成功</td> 
  </tr> 
 </tbody> 
</table>

ModularRealmAuthenticator 内置的认证策略默认实现是AtLeastOneSuccessfulStrategy 方式，因为这种方式也是被广泛使用的一种认证策略。当然，你也可以通过配置文件定义你需要的策略，如：

[main]  
    ...  
    authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy  
    securityManager.authenticator.authenticationStrategy = $authcStrategy  
    ...

3、Realm的顺序   
由刚才提到的认证策略，可以看到Realm在ModularRealmAuthenticator 里面的顺序对认证是有影响的。   
ModularRealmAuthenticator 会读取配置在SecurityManager里的Realm。当执行认证是，它会遍历Realm集合，对所有支持提交的token的Realm调用getAuthenticationInfo 。   
因此，如果Realm的顺序对你使用的认证策略结果有影响，那么你应该在配置文件中明确定义Realm的顺序，如：

blahRealm = com.company.blah.Realm  
    ...  
    fooRealm = com.company.foo.Realm  
    ...  
    barRealm = com.company.another.Realm  
      
    securityManager.realms = $fooRealm, $barRealm, $blahRealm

# Shiro的授权机制 #

授权即访问控制，它将判断用户在应用程序中对资源是否拥有相应的访问权限。   
如，判断一个用户有查看页面的权限，编辑数据的权限，拥有某一按钮的权限，以及是否拥有打印的权限等等。

一、授权的三要素

授权有着三个核心元素：权限、角色和用户。

权限   
权限是Apache Shiro安全机制最核心的元素。它在应用程序中明确声明了被允许的行为和表现。一个格式良好好的权限声明可以清晰表达出用户对该资源拥有的权限。   
大多数的资源会支持典型的CRUD操作（create,read,update,delete）,但是任何操作建立在特定的资源上才是有意义的。因此，权限声明的根本思想就是建立在资源以及操作上。   
而我们通过权限声明仅仅能了解这个权限可以在应用程序中做些什么，而不能确定谁拥有此权限。   
于是，我们就需要在应用程序中对用户和权限建立关联。   
通常的做法就是将权限分配给某个角色，然后将这个角色关联一个或多个用户。

权限声明及粒度   
Shiro权限声明通常是使用以冒号分隔的表达式。就像前文所讲，一个权限表达式可以清晰的指定资源类型，允许的操作，可访问的数据。同时，Shiro权限表达式支持简单的通配符，可以更加灵活的进行权限设置。   
下面以实例来说明权限表达式。   
可查询用户数据   
User:view   
可查询或编辑用户数据   
User:view,edit   
可对用户数据进行所有操作   
User:\* 或 user   
可编辑id为123的用户数据   
User:edit:123

角色   
Shiro支持两种角色模式：   
1、传统角色：一个角色代表着一系列的操作，当需要对某一操作进行授权验证时，只需判断是否是该角色即可。这种角色权限相对简单、模糊，不利于扩展。   
2、权限角色：一个角色拥有一个权限的集合。授权验证时，需要判断当前角色是否拥有该权限。这种角色权限可以对该角色进行详细的权限描述，适合更复杂的权限设计。   
下面将详细描述对两种角色模式的授权实现。

二、授权实现

Shiro支持三种方式实现授权过程：   
编码实现  
注解实现  
JSP Taglig实现  
1、基于编码的授权实现

1.1基于传统角色授权实现   
当需要验证用户是否拥有某个角色时，可以调用Subject 实例的hasRole\*方法验证。

Subject currentUser = SecurityUtils.getSubject();  
    if (currentUser.hasRole("administrator")) {  
        //show the admin button  
    } else {  
        //don't show the button?  Grey it out?  
    }

相关方法如下：

<table> 
 <tbody> 
  <tr> 
   <td>Subject方法&nbsp;&nbsp; &nbsp;</td> 
   <td style="width:481px;">描述</td> 
  </tr> 
  <tr> 
   <td>isPermitted(Permission p)&nbsp;&nbsp; &nbsp;</td> 
   <td style="width:481px;">Subject拥有制定权限时，返回treu</td> 
  </tr> 
  <tr> 
   <td>isPermitted(List&lt;Permission&gt; perms)&nbsp;&nbsp;</td> 
   <td style="width:481px;">&nbsp;返回对应权限的boolean数组</td> 
  </tr> 
  <tr> 
   <td>isPermittedAll(Collection&lt;Permission&gt; perms)&nbsp;&nbsp; &nbsp;</td> 
   <td style="width:481px;">Subject拥有所有制定权限时，返回true</td> 
  </tr> 
 </tbody> 
</table>

2、 基于字符串的实现   
相比笨重的基于对象的实现方式，基于字符串的实现便显得更加简洁。

Subject currentUser = SecurityUtils.getSubject();  
    if (currentUser.isPermitted("printer:print:laserjet4400n")) {  
        //show the Print button  
    } else {  
        //don't show the button?  Grey it out?  
    }

使用冒号分隔的权限表达式是org.apache.shiro.authz.permission.WildcardPermission 默认支持的实现方式。   
这里分别代表了 资源类型：操作：资源ID

类似基于对象的实现相关方法，基于字符串的实现相关方法：   
isPermitted(String perm)、isPermitted(String... perms)、isPermittedAll(String... perms)

基于权限对象的断言实现

Subject currentUser = SecurityUtils.getSubject();  
    //guarantee that the current user is permitted  
    //to open a bank account:  
    Permission p = new AccountPermission("open");  
    currentUser.checkPermission(p);  
    openBankAccount();

基于字符串的断言实现

Subject currentUser = SecurityUtils.getSubject();  
    //guarantee that the current user is permitted  
    //to open a bank account:  
    currentUser.checkPermission("account:open");  
    openBankAccount();

断言实现的相关方法

<table> 
 <tbody> 
  <tr> 
   <td>Subject方法&nbsp;&nbsp; &nbsp;</td> 
   <td style="width:399px;">说明</td> 
  </tr> 
  <tr> 
   <td>checkPermission(Permission p)&nbsp;&nbsp;</td> 
   <td style="width:399px;">断言用户是否拥有制定权限</td> 
  </tr> 
  <tr> 
   <td>checkPermission(String perm)&nbsp;&nbsp;</td> 
   <td style="width:399px;">&nbsp;断言用户是否拥有制定权限</td> 
  </tr> 
  <tr> 
   <td>checkPermissions(Collection&lt;Permission&gt; perms)&nbsp;</td> 
   <td style="width:399px;">&nbsp;断言用户是否拥有所有指定权限</td> 
  </tr> 
  <tr> 
   <td>checkPermissions(String... perms)&nbsp;&nbsp;</td> 
   <td style="width:399px;">&nbsp;断言用户是否拥有所有指定权限</td> 
  </tr> 
 </tbody> 
</table>

2、基于注解的授权实现   
Shiro注解支持AspectJ、Spring、Google-Guice等，可根据应用进行不同的配置。

相关的注解：   
@ RequiresAuthentication   
可以用户类/属性/方法，用于表明当前用户需是经过认证的用户。

@RequiresAuthentication  
    public void updateAccount(Account userAccount) {  
        //this method will only be invoked by a   
        //Subject that is guaranteed authenticated  
        ...  
    }

@ RequiresGuest   
表明该用户需为”guest”用户

@ RequiresPermissions   
当前用户需拥有制定权限

@RequiresPermissions("account:create")  
    public void createAccount(Account account) {  
        //this method will only be invoked by a Subject  
        //that is permitted to create an account  
        ...  
    }

@RequiresRoles   
当前用户需拥有制定角色

@ RequiresUser   
当前用户需为已认证用户或已记住用户

3、基于JSP  TAG的授权实现   
Shiro提供了一套JSP标签库来实现页面级的授权控制。   
在使用Shiro标签库前，首先需要在JSP引入shiro标签：

<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>

下面一一介绍Shiro的标签：   
guest标签   
验证当前用户是否为“访客”，即未认证（包含未记住）的用户

<shiro:guest>  
        Hi there!  Please <a href="login.jsp">Login</a> or <a href="signup.jsp">Signup</a> today!  
    </shiro:guest>

user标签   
认证通过或已记住的用户

<shiro:user>  
        Welcome back John!  Not John? Click <a href="login.jsp">here<a> to login.  
    </shiro:user>

authenticated标签   
已认证通过的用户。不包含已记住的用户，这是与user标签的区别所在。

<shiro:authenticated>  
        <a href="updateAccount.jsp">Update your contact information</a>.  
    </shiro:authenticated>

notAuthenticated标签   
未认证通过用户，与authenticated标签相对应。与guest标签的区别是，该标签包含已记住用户。

<shiro:notAuthenticated>  
        Please <a href="login.jsp">login</a> in order to update your credit card information.  
    </shiro:notAuthenticated>

principal 标签   
输出当前用户信息，通常为登录帐号信息

Hello, <shiro:principal/>, how are you today?

hasRole标签   
验证当前用户是否属于该角色

<shiro:hasRole name="administrator">  
        <a href="admin.jsp">Administer the system</a>  
    </shiro:hasRole>

lacksRole标签   
与hasRole标签逻辑相反，当用户不属于该角色时验证通过

<shiro:lacksRole name="administrator">  
        Sorry, you are not allowed to administer the system.  
    </shiro:lacksRole>

hasAnyRole标签   
验证当前用户是否属于以下任意一个角色。

<shiro:hasAnyRoles name="developer, project manager, administrator">  
        You are either a developer, project manager, or administrator.  
    </shiro:lacksRole>

hasPermission标签   
验证当前用户是否拥有制定权限

<shiro:hasPermission name="user:create">  
        <a href="createUser.jsp">Create a new User</a>  
    </shiro:hasPermission>

lacksPermission标签   
与hasPermission标签逻辑相反，当前用户没有制定权限时，验证通过

<shiro:lacksPermission name="user:create">  
        <a href="createUser.jsp">Create a new User</a>  
    </shiro:lacksPermission>

三、Shiro授权的内部处理机制   
   
1、在应用程序中调用授权验证方法(Subject的isPermitted\*或hasRole\*等)   
2、Sbuject的实例通常是DelegatingSubject类（或子类）的实例对象，在认证开始时，会委托应用程序设置的securityManager实例调用相应的isPermitted\*或hasRole\*方法。   
3、接下来SecurityManager会委托内置的Authorizer的实例（默认是ModularRealmAuthorizer 类的实例，类似认证实例，它同样支持一个或多个Realm实例认证）调用相应的授权方法。   
4、每一个Realm将检查是否实现了相同的 Authorizer 接口。然后，将调用Reaml自己的相应的授权验证方法。

当使用多个Realm时，不同于认证策略处理方式，授权处理过程中：   
1、当调用Realm出现异常时，将立即抛出异常，结束授权验证。   
2、只要有一个Realm验证成功，那么将认为授权成功，立即返回，结束认证。

～Shiro 认证,授权实现查看原文

原文地址：[https://blog.csdn.net/xiaoliuliu2050/article/details/54911480][https_blog.csdn.net_xiaoliuliu2050_article_details_54911480]

### Shiro 实战： ###

spring boot + Shiro 整合：[传送门][Link 1]

spring mvc + Shiro 整合 ：[传送门2][2]

[format_png]: /images/20220301/cdbf8b35ebcc4fdfba96ef2da830558f.png
[format_png 1]: /images/20220301/2c4b6698d4a2445d9dac79fe5af3e6eb.png
[format_png 2]: /images/20220301/8bc258e436614e8293fc32c157ba167b.png
[https_blog.csdn.net_xiaoliuliu2050_article_details_54911480]: https://blog.csdn.net/xiaoliuliu2050/article/details/54911480
[Link 1]: https://blog.csdn.net/u013615903/article/details/78781166/
[2]: https://blog.csdn.net/qq_39874546/article/details/79081950