基于【编程不良人】2020最新版Shiro教程,整合SpringBoot项目实战教程
哔哩哔哩链接：https://www.bilibili.com/video/BV1uz4y197Zm?p=1
一、权限的管理1.1 什么是权限管理
基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。
1.2 什么是身份认证
身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。
1.3 什么是授权
授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的
二、什么是shiroApache Shiro™ is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the smallest mobile applications to the largest web and enterprise applications.
Shiro 是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。使用Shiro易于理解的API，您可以快速轻松地保护任何应用程序—从最小的移动应用程序到最大的web和企业应用程序。
Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。
三、shiro的核心架构3.1 Subject
Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。
Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权
3.2 SecurityManager
SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。
SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。
3.3 Authenticator
Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。
3.4 Authorizer
Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。
3.5 Realm
Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。
3.6 SessionManager
sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。
3.7 SessionDAO
SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。
3.8 CacheManager
CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。
3.9 Cryptography
Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。
身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。
4.2 shiro中认证的关键对象-
Subject：主体
访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体； -
Principal：身份信息
是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。 -
credential：凭证信息
是只有主体自己知道的安全信息，如密码、证书等。
1. 创建springboot项目并引入shiro依赖
org.apache.shiro shiro-core 1.5.3
2. 引入shiro配置文件
配置文件：名称随意，以 .ini 结尾，放在 resources 目录下，我们此处创建一个shiro.ini文件
注意：在实际的项目开发中并不会使用这种方式，这种方法可以用来初学时练手
[users] 表示我们的所有用户，以键=值的方式存放用户名密码，我们的shiro.ini文件内容如下：
[users] zhangsan=123456 lisi=456789
3.开发认证代码
我们在项目的的test目录下编写代码测试，测试发现认证通过，因为我们的的用户名和密码与shiro.ini中的对应。
测试代码如下：
package com.example.demo;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class DemoApplicationTests {
@Test
void contextLoads() {
// 1.创建安全管理器对象，所有认证和授权都在安全管理器对象中进行，DefaultSecurityManager实现了SecurityManager接口
DefaultSecurityManager securityManager = new DefaultSecurityManager();
// 2.给安全管理器设置realm（securityManager进行安全认证需要通过Realm获取用户权限数据）
securityManager.setRealm(new IniRealm("classpath:shiro.ini"));
// 3.SecurityUtils：全局的安全工具类，我们需要借助它完成认证、退出等操作，
// 给全局安全工具类设置安全管理器
SecurityUtils.setSecurityManager(securityManager);
// 4.关键对象subject主体
// 拿到当前登录的主体对象
Subject subject = SecurityUtils.getSubject();
// 5.创建令牌，用户名密码的令牌，此处我们假设要登录的用户名为 zhangsan ，密码为 123
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
System.out.println("认证状态" + subject.isAuthenticated());// 未认证状态，fasle
//用户认证
subject.login(token);
System.out.println("认证状态" + subject.isAuthenticated()); //是否认证成功
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("认证失败，用户名不存在");
} catch (IncorrectCredentialsException e) {
e.printStackTrace();
System.out.println("认证失败，密码错误");
}
}
}
如果认证不通过，会报异常，以下是shiro认证常见的异常类型：
4.shiro认证常见的异常类型
-
UnknownAccountException（用户名异常）
-
IncorrectCredentialsException（密码错误异常）
-
DisabledAccountException（帐号被禁用）
-
LockedAccountException（帐号被锁定）
-
ExcessiveAttemptsException（登录失败次数过多）
-
ExpiredCredentialsException（凭证过期）等
通过分析shiro源码可知，shiro的认证：
1.最终执行用户名比较是在SimpleAccountRealm类 的 doGetAuthenticationInfo方法中完成用户名校验
2.最终密码校验是在 AuthenticatingRealm类 的assertCredentialsMatch方法 中（密码的校验由shiro自动完成）
自定义Realm的作用：放弃使用.ini文件，使用数据库查询用户数据
上面我们的测试使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。
1.shiro提供的Realm
2.根据认证源码发现认证使用的是SimpleAccountRealm
总结shiro的认证与授权：
认证 ： AuthenticatingRealm 类中的 doGetAuthenticationInfo中
授权 ：AuthorizingRealm 类中的 doGetAuthorizationInfo中
弄懂认证和授权要重写的方法后，我们自定义一个realm，继承 AuthorizingRealm ，并重写本类AuthorizingRealm 的doGetAuthorizationInfo方法（授权）和父类AuthenticatingRealm的doGetAuthenticationInfo方法（认证），
重写方法，我们此处先书写认证的代码，认证需要我们返回一个AuthenticationInfo对象，我们可以使用SimpleAuthenticationInfo或者SimpleAccount，一般我们使用SimpleAuthenticationInfo，
认证代码如下（授权我们在后面进行学习）：
package com.example.demo.shiro.realm;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class CustomerRealm extends AuthorizingRealm {
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
// authenticationToken.getPrincipal() 即用户名，我们可以强转类型为string
// 在token中获取 用户名
String principal = (String) authenticationToken.getPrincipal();
System.out.println(principal);
// 实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库，在这里只做简单的演示
// 假设username,password是从数据库获得的信息
String username="zhangsan";
String password="123";
if(username.equals(principal)){
// 参数1:返回数据库中正确的用户名
// 参数2:返回数据库中正确密码
// 参数3:提供当前realm的名字，realm的名字都是程序运行时底层生成的 我们直接调用父类中的this.getName(); 即可
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password,this.getName());
return simpleAuthenticationInfo;
}
return null;
}
}
之后我们在项目test目录下新建一个测试方法，测试发现输出了我们的用户名和登录成功，
具体测试代码如下：
@Test
void contextLoads1() {
// 1.创建安全管理对象 securityManager
DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
// 2.给安全管理器设置realm（设置为自定义realm获取认证数据）
defaultSecurityManager.setRealm(new CustomerRealm());
// IniRealm realm = new IniRealm("classpath:shiro.ini");
// 3.给安装工具类中设置默认安全管理器
SecurityUtils.setSecurityManager(defaultSecurityManager);
// 4.获取主体对象subject
Subject subject = SecurityUtils.getSubject();
// 5.创建token令牌，这里假设用户输入的用户名为zhangsan，密码为123
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
subject.login(token);// 用户登录
System.out.println("登录成功~~");
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("用户名错误!!");
} catch (IncorrectCredentialsException e) {
e.printStackTrace();
System.out.println("密码错误!!!");
}
}
扩展：查看某个类的继承关系
我们在ideal中 输入代码 Realm ，再按快捷键crtl+h可查看Realm的继承关系
或者右键它，点击 show Diagram ，可以查看类图
在弹出的界面右键，即可查看对象的关系
4.6 使用MD5加密算法MD5算法
作用：一般用来加密或者签名
特点：MD5算法不可逆，如何内容相同无论执行多少次md5生成结果始终是一致
网络上提供的MD5在线解密一般是用穷举的方法
生成结果：始终是一个16进制32位长度字符串
MD5的基本使用：
shiro集成了md5的加密算法，我们先来了解md5的基本使用，我们继续在项目的test包下新建测试方法进行测试，
测试代码如下：
@Test
void contextLoads2() {
// 使用md5
Md5Hash md5Hash = new Md5Hash("123");
System.out.println(md5Hash.toHex());
// 使用MD5 + salt处理，默认salt是加在123的前面的，即对 X0*7ps123 进行加密
Md5Hash md5Hash1 = new Md5Hash("123", "X0*7ps");
System.out.println(md5Hash1.toHex());
// 使用md5 + salt + hash散列（参数代表要散列多少次，一般是 1024或2048），散列的次数越多越安全
Md5Hash md5Hash2 = new Md5Hash("123", "X0*7ps", 1024);
System.out.println(md5Hash2.toHex());
}
之后我们想要对我们的密码进行加密处理，在前面源码的分析中我们知道shiro中密码的比较是在 AuthenticatingRealm类下的assertCredentialsMatch方法中进行比较，且默认是equal比较（shiro的默认密码比较器是SimpleCredentialsMacher，而我们点进去SimpleCredentialsMacher源码发现这个密码比较器默认就是equal比较）
由此我们知道 getCredentialsMatcher 用于获取密码比较器，那么我们可以知道它肯定有setCredentialsMatcher方法用于设置配置匹配器，
我们右键 CredentialsMatcher 点击 Show Diagram 查看它的继承关系
结果如下，发现它有三个实现方法，因为我们想要对密码进行md5的加密方法，所以我们选择HashedCredentialsMatcher的密码比较器
之后我们需要更改默认的密码比较器，我们需要更改代码，注意，shiro的md5加密有三种方法，一是单独使用md5进行加密的方式，二是使用md5+salt加密的方式，三是使用md5+salt+hash加密的方式，接下来我们逐一介绍。
单独使用md5加密的方式我们需要更改自定义CustomerRealm.java的认证方法，将密码改为进行md5加密后的密码
之后新增测试方法进行测试，测试方法指定使用的密码比较器和加密方式（注意，HashedCredentialsMatcher这个密码比较器里面有很多种加密方式，md5加密只是其中的一种，所以我们需要指定使用的加密算法为md5），测试发现登录成功，
测试代码如下：
@Test
void contextLoads3() {
// 1.创建安全管理器
DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
// 2.注入realm
CustomerRealm realm = new CustomerRealm();
// 3.设置realm使用hash凭证匹配器
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
// 声明：使用的算法
credentialsMatcher.setHashAlgorithmName("md5");
realm.setCredentialsMatcher(credentialsMatcher);
defaultSecurityManager.setRealm(realm);
// 4.将安全管理器注入安全工具
SecurityUtils.setSecurityManager(defaultSecurityManager);
// 5.通过安全工具类获取subject
Subject subject = SecurityUtils.getSubject();
// 6.认证
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
subject.login(token);
System.out.println("登录成功");
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("用户名错误");
} catch (IncorrectCredentialsException e) {
e.printStackTrace();
System.out.println("密码错误");
}
}
使用md5+salt加密的方式
我们也需要修改CustomerRealm.java的认证方法，将密码改为进行md5+slat加密后的密码，同时通过ByteSource.Util.bytes(随机盐)的方式将随机盐告诉shiro，ByteSource这个接口是shiro源码中的，用于将盐告诉shiro，具体代码如下：
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
// authenticationToken.getPrincipal() 即用户名，我们可以强转类型为string
// 在token中获取 用户名
String principal = (String) authenticationToken.getPrincipal();
System.out.println(principal);
// 实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库，在这里只做简单的演示
// 假设username,password是从数据库获得的信息
String username="zhangsan";
String password="8a83592a02263bfe6752b2b5b03a4799";
if(username.equals(principal)){
// 参数1:返回数据库中正确的用户名
// 参数2:返回数据库中正确密码
// 参数3:通过ByteSource.Util.bytes(随机盐)的方式将随机盐告诉shiro
// 参数4:提供当前realm的名字，realm的名字都是程序运行时底层生成的 我们直接调用父类中的this.getName(); 即可
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password, ByteSource.Util.bytes("X0*7ps"),this.getName());
return simpleAuthenticationInfo;
}
return null;
}
我们继续回到test目录下进行测试，我们的测试方法和md5加密的测试方法是一样的，不用更改代码，运行测试发现登录成功
使用md5+salt+hash加密的方式我们也需要修改CustomerRealm的认证方法，将密码改为进行md5+slat+散列加密后的密码，同时通过ByteSource.Util.bytes(随机盐)的方式将随机盐告诉shiro，
我们继续回到test目录下进行测试，新增测试方法，运行测试发现登录成功
- 注意，此处需要将散列的次数告诉shiro，因为如果不将散列的次数告诉shiro，那么它默认只会进行散列一次，即我们上面介绍的md5+salt加密就是散列一次
测试代码如下：
@Test
void contextLoads5() {
// 1.创建安全管理器
DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
// 2.注入realm
CustomerRealm realm = new CustomerRealm();
// 3.设置realm使用hash凭证匹配器
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
// 声明：使用的算法
credentialsMatcher.setHashAlgorithmName("md5");
// 声明：散列次数
credentialsMatcher.setHashIterations(1024);
realm.setCredentialsMatcher(credentialsMatcher);
defaultSecurityManager.setRealm(realm);
// 4.将安全管理器注入安全工具
SecurityUtils.setSecurityManager(defaultSecurityManager);
// 5.通过安全工具类获取subject
Subject subject = SecurityUtils.getSubject();
// 6.认证
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
subject.login(token);
System.out.println("登录成功");
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("用户名错误");
} catch (IncorrectCredentialsException e) {
e.printStackTrace();
System.out.println("密码错误");
}
}
五、shiro中的授权
5.1 授权
授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。
5.2 关键对象授权可简单理解为who对what(which)进行How操作：
Who，即主体（Subject），主体需要访问系统中的资源。
What，即资源（Resource)，如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。
How，权限/许可（Permission)，规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。
5.3 授权流程 5.4 授权方式-
基于角色的访问控制
-
RBAC基于角色的访问控制（Role-based Access Control）是以角色为中心进行访问控制
if(subject.hasRole("admin")){ //操作什么资源 }
-
-
基于资源的访问控制
-
RBAC基于资源的访问控制（Resource-based Access Control）是以资源为中心进行访问控制
if(subject.isPermission("user:update:01")){ //资源实例 //对资源01用户具有修改的权限 } if(subject.isPermission("user:update:*")){ //资源类型 //对 所有的资源 用户具有更新的权限 }
-
权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。
例子：
- 用户创建权限：user:create，或user:create:*
- 用户修改实例001的权限：user:update:001
- 用户实例001的所有权限：user:*：001
-
编程式
Subject subject = SecurityUtils.getSubject(); if(subject.hasRole(“admin”)) { //有权限 } else { //无权限 } -
注解式
@RequiresRoles("admin") public void hello() { //有权限 } -
标签式
JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
我们在CustomerRealm中书写授权的代码，具体代码如下：
package com.example.demo.shiro.realm;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
public class CustomerRealm extends AuthorizingRealm {
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
// 一个主体可以有多个身份，但只能有一个主身份
// 拿到主身份信息，即用户名
String primaryPrincipal = (String)principalCollection.getPrimaryPrincipal();
System.out.println("身份信息: "+primaryPrincipal); //用户名
// 根据身份信息 用户名 获取当前用户的角色信息，以及权限信息
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
// 假设 admin,user 是从数据库查到的 角色信息
simpleAuthorizationInfo.addRole("admin");
simpleAuthorizationInfo.addRole("user");
// 假设 ... 是从数据库查到的 权限信息赋值给权限对象
simpleAuthorizationInfo.addStringPermission("user:*:01");
// 第三个参数为*则可以省略
simpleAuthorizationInfo.addStringPermission("prodect:*");
return simpleAuthorizationInfo;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
// authenticationToken.getPrincipal() 即用户名，我们可以强转类型为string
// 在token中获取 用户名
String principal = (String) authenticationToken.getPrincipal();
System.out.println(principal);
// 实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库，在这里只做简单的演示
// 假设username,password是从数据库获得的信息
String username="zhangsan";
String password="e4f9bf3e0c58f045e62c23c533fcf633";
if(username.equals(principal)){
// 参数1:返回数据库中正确的用户名
// 参数2:返回数据库中正确密码
// 参数3:通过ByteSource.Util.bytes(随机盐)的方式将随机盐告诉shiro
// 参数4:提供当前realm的名字，realm的名字都是程序运行时底层生成的 我们直接调用父类中的this.getName(); 即可
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password, ByteSource.Util.bytes("X0*7ps"),this.getName());
return simpleAuthenticationInfo;
}
return null;
}
}
我们继续回到test目录下进行测试，新增测试方法，测试代码如下：
@Test
void contextLoads6() {
//1.创建安全管理器
DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
//2.注入realm
CustomerRealm realm = new CustomerRealm();
//3.设置realm使用hash凭证匹配器
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
//声明：使用的算法
credentialsMatcher.setHashAlgorithmName("md5");
//声明：散列次数
credentialsMatcher.setHashIterations(1024);
realm.setCredentialsMatcher(credentialsMatcher);
defaultSecurityManager.setRealm(realm);
//4.将安全管理器注入安全工具
SecurityUtils.setSecurityManager(defaultSecurityManager);
//5.通过安全工具类获取subject
Subject subject = SecurityUtils.getSubject();
//6.认证
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
try {
subject.login(token);
System.out.println("登录成功");
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("用户名错误");
} catch (IncorrectCredentialsException e) {
e.printStackTrace();
System.out.println("密码错误");
}
// 授权
if (subject.isAuthenticated()) {
// 基于角色权限控制
System.out.println(subject.hasRole("admin"));
// 基于多角色的权限控制，hasAllRoles需要的是一个集合对象，我们可以通过Arrays.asList("admin", "user")将其转换为集合
// hasAllRoles表示同时需要有这些角色，注意：每次判断都会调用一次授权方法，如下面两个角色的判断就调用两次授权方法（doGetAuthorizationInfo）
System.out.println(subject.hasAllRoles(Arrays.asList("admin", "user")));
System.out.println(subject.hasAllRoles(Arrays.asList("admin", "manager")));
// 是否具有其中一个角色
boolean[] booleans = subject.hasRoles(Arrays.asList("admin", "user", "manager"));
for (boolean aBoolean : booleans) {
System.out.println(aBoolean);
}
System.out.println("====这是一个分隔符====");
// 基于权限字符串的访问控制 资源标识符：操作：资源类型
// 用户具有的权限 *:*:* 表示所有权限，即超级管理员
// user:*:01 表示对user的01资源具有任意的操作权限 prodect:* 表示对product的任意资源具有任意的操作权限
System.out.println("权限:" + subject.isPermitted("user:update:01"));
System.out.println("权限:" + subject.isPermitted("prodect:update:02"));
// 分别具有哪些权限
boolean[] permitted = subject.isPermitted("user:*:01", "user:update:02");
for (boolean b : permitted) {
System.out.println(b);
}
//同时具有哪些权限，要都有才返回true
boolean permittedAll = subject.isPermittedAll("prodect:*:01", "prodect:update:03");
System.out.println(permittedAll);
}
}
测试结果如下：
源码获取至此，我们的SpringBoot整合Shiro（上）就讲解完成了。中篇我们将进行Shiro与Jsp页面整合的讲解。源码和数据库文件可以通过关注我的微信公众号 我爱学习呀嘻嘻 ，回复关键字“shiro集成”进行获取哦。
SpringBoot整合Shiro学习(中)
SpringBoot整合Shiro学习(下)
