SpringBoot整合Shiro学习(上)

已于 2022-06-29 09:25:50 修改
阅读量2.9k 收藏 5
点赞数 1
文章标签： spring boot shiro mybatis redis ehcache
于 2021-11-21 19:25:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45745964/article/details/121458402
版权

SpringBoot整合Shiro（上）

基于【编程不良人】2020最新版Shiro教程,整合SpringBoot项目实战教程

哔哩哔哩链接：https://www.bilibili.com/video/BV1uz4y197Zm?p=1

一、权限的管理

1.1 什么是权限管理

基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。

权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。

1.2 什么是身份认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。

1.3 什么是授权

授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的

二、什么是shiro

Apache 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的核心架构

image-20211119151951244

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提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

四、shiro中的认证

4.1 认证

​ 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。

4.2 shiro中认证的关键对象

  • Subject：主体
    访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；

  • Principal：身份信息
    是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。

  • credential：凭证信息
    是只有主体自己知道的安全信息，如密码、证书等。

4.3 认证流程

image-20211119152650774

4.4 认证的开发

1. 创建springboot项目并引入shiro依赖

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.5.3</version>
</dependency>

2. 引入shiro配置文件

配置文件：名称随意，以 .ini 结尾，放在 resources 目录下，我们此处创建一个shiro.ini文件

注意：在实际的项目开发中并不会使用这种方式，这种方法可以用来初学时练手

[users] 表示我们的所有用户，以键=值的方式存放用户名密码，我们的shiro.ini文件内容如下：

[users]
zhangsan=123456
lisi=456789

image-20211119154229886

3.开发认证代码

我们在项目的的test目录下编写代码测试，测试发现认证通过，因为我们的的用户名和密码与shiro.ini中的对应。

image-20211119160641825

测试代码如下：

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 {

    /* ini方式认证测试 */
    @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（凭证过期）等

4.5 自定义Realm

通过分析shiro源码可知，shiro的认证：

1.最终执行用户名比较是在SimpleAccountRealm类 的 doGetAuthenticationInfo方法中完成用户名校验

image-20211119161751477

2.最终密码校验是在 AuthenticatingRealm类 的assertCredentialsMatch方法 中（密码的校验由shiro自动完成）

image-20211119162000162

自定义Realm的作用：放弃使用.ini文件，使用数据库查询用户数据

上面我们的测试使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。

1.shiro提供的Realm

image-20211119161310824

2.根据认证源码发现认证使用的是SimpleAccountRealm

image-20211119161351777

总结shiro的认证与授权：

​ 认证 ： AuthenticatingRealm 类中的 doGetAuthenticationInfo中

​ 授权 ：AuthorizingRealm 类中的 doGetAuthorizationInfo中

弄懂认证和授权要重写的方法后，我们自定义一个realm，继承 AuthorizingRealm ，并重写本类AuthorizingRealm 的doGetAuthorizationInfo方法（授权）和父类AuthenticatingRealm的doGetAuthenticationInfo方法（认证），

image-20211119165019620

重写方法，我们此处先书写认证的代码，认证需要我们返回一个AuthenticationInfo对象，我们可以使用SimpleAuthenticationInfo或者SimpleAccount，一般我们使用SimpleAuthenticationInfo，

image-20211119170637612

认证代码如下（授权我们在后面进行学习）：

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目录下新建一个测试方法，测试发现输出了我们的用户名和登录成功，

image-20211119171528523

具体测试代码如下：

	/* 自定义realm认证测试 */
    @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的继承关系

image-20211119163057303

或者右键它，点击 show Diagram ，可以查看类图

image-20211119163200219
ps：如果右键没有Diagrams，可能是因为你未安装对应的插件，在ideal的插件里搜索UML和jBoss jBPM依次进行安装，之后重启ideal即可。
在这里插入图片描述

在这里插入图片描述

在弹出的界面右键，即可查看对象的关系

image-20211119163436849

4.6 使用MD5加密算法

MD5算法

作用：一般用来加密或者签名

特点：MD5算法不可逆，如何内容相同无论执行多少次md5生成结果始终是一致

网络上提供的MD5在线解密一般是用穷举的方法

生成结果：始终是一个16进制32位长度字符串

MD5的基本使用：

shiro集成了md5的加密算法，我们先来了解md5的基本使用，我们继续在项目的test包下新建测试方法进行测试，

image-20211119172213163

测试代码如下：

	/* 密码md5加密处理 */
    @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比较）

image-20211119172829531

image-20211119173223815

image-20211121161647821

由此我们知道 getCredentialsMatcher 用于获取密码比较器，那么我们可以知道它肯定有setCredentialsMatcher方法用于设置密码比较器，

image-20211119173537851

我们右键 CredentialsMatcher 点击 Show Diagram 查看它的继承关系

image-20211119173926195

结果如下，发现它有三个实现方法，因为我们想要对密码进行md5的加密方法，所以我们选择HashedCredentialsMatcher的密码比较器

image-20211119174249617

之后我们需要更改默认的密码比较器，我们需要更改代码，注意，shiro的md5加密有三种方法，一是单独使用md5进行加密的方式，二是使用md5+salt加密的方式，三是使用md5+salt+hash加密的方式，接下来我们逐一介绍。

单独使用md5加密的方式

我们需要更改自定义CustomerRealm.java的认证方法，将密码改为进行md5加密后的密码

image-20211119175347485

之后新增测试方法进行测试，测试方法指定使用的密码比较器和加密方式（注意，HashedCredentialsMatcher这个密码比较器里面有很多种加密方式，md5加密只是其中的一种，所以我们需要指定使用的加密算法为md5），测试发现登录成功，

image-20211119175157878

测试代码如下：

	/* 自定义realm认证测试-加密方式为md5或md5+salt */
    @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加密的测试方法是一样的，不用更改代码，运行测试发现登录成功

image-20211119180719287

使用md5+salt+hash加密的方式

我们也需要修改CustomerRealm的认证方法，将密码改为进行md5+slat+散列加密后的密码，同时通过ByteSource.Util.bytes(随机盐)的方式将随机盐告诉shiro，

image-20211119181424782

我们继续回到test目录下进行测试，新增测试方法，运行测试发现登录成功

  • 注意，此处需要将散列的次数告诉shiro，因为如果不将散列的次数告诉shiro，那么它默认只会进行散列一次，即我们上面介绍的md5+salt加密就是散列一次

image-20211119181140275

测试代码如下：

	/* 自定义realm认证测试-加密方式为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 授权流程

image-20211119181746778

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:*")){  //资源类型
  //对 所有的资源 用户具有更新的权限
}

5.5 权限字符串

权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。

例子：

  • 用户创建权限：user:create，或 user:create:*
  • 用户修改实例001的权限：user:update:001
  • 用户实例001的所有权限：user:*：001

5.6 shiro中授权编程实现方式

  • 编程式

    Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
	//有权限
} else {
	//无权限
}

  • 注解式

    @RequiresRoles("admin")
public void hello() {
	//有权限
}

  • 标签式

    JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
<shiro:hasRole name="admin">
	<!— 有权限—>
</shiro:hasRole>
注意: Thymeleaf 中使用shiro需要额外集成!

5.7 开发授权

我们在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目录下进行测试，新增测试方法，测试代码如下：

	/* 自定义realm认证测试-加密方式为md5+salt+散列次数，授权测试 */
    @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);
        }

    }

测试结果如下：

image-20211119184511384

源码获取

至此，我们的SpringBoot整合Shiro(上)就讲解完成了。中篇我们将进行Shiro与Jsp页面整合的讲解。源码和数据库文件可以通过关注我的微信公众号 我爱学习呀嘻嘻 ，回复关键字shiro集成进行获取哦。

SpringBoot整合Shiro学习(中)：Shiro与Jsp页面整合

SpringBoot整合Shiro学习(下)：Shiro与Thymeleaf整合

image-20211108230322493

我爱学习呀
关注
SpringBoot+Shiro学习总结-入门
LeopaLY的博客
04-29 603
Shiro总结 在pom.xml文件中介入响应的shiro依赖 <!--shiro与spring的整合依赖--> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactI...
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
Springboot+shiro简单登录案例
06-06
Shiro的简单登录，如若没有足够积分下载可留下邮箱或者私信我，直接发到你们邮箱，文章链接：https://blog.csdn.net/sutongxuevip/article/details/80584607
39 Spring Boot Shiro权限管理【从零开始学Spring Boot】
悟纤学院
08-20 1万+
这个章节牵涉到知识点比较多，具体参考如下教程： 39.4 Spring Boot Shiro权限管理【从零开始学Spring Boot】   39.3 Spring Boot Shiro权限管理【从零开始学Spring Boot】   39.2. Spring Boot Shiro权限管理【从零开始学Spring Boot】   39.1 Spring Boot Shir
shiro笔记（九）springboot 项目整合shiro框架，实现的详细步骤（一步一步整合，拿上用就可以）
一天不写代码难受的博客
08-07 281
目录 具体功能： 使用shiro框架实现登录功能，这个登录功能有记住我功能，加密密码验证功能。不同用户权限不一样，看到的东西不一样。从数据库里面查询出来的权限放到缓冲里面。 1 首先创建一个springboot的maven项目 2 导入依赖 <!--配置继承--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>sp
Shiro入门学习（整合SpringBoot）
qq_25046827的博客
04-03 4581
Apache Shiro是Java的一个安全（权限）框架 可以完成：认证、授权、加密、会话管理、与Web集成和缓存等 用户登录时把身份信息（用户名/手机号/邮箱地址等）和凭证信息（密码/证书等）封装成一个Token令牌，通过安全管理器中的认证器进行校验，成功则授权以访问系统 shiro三大功能模块 Subject：主体，一般指用户。 SecurityManager：安全管理器，管理所有Subject，可以配合内部安全组件。(类似于SpringMVC中的DispatcherServlet) Rea.
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录
06-19
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 ...
springboot整合shiro
03-30
**SpringBoot整合Shiro**是将流行的Java Web框架Spring Boot与安全管理框架Apache Shiro结合，以构建高效、安全的Web应用程序。Spring Boot以其简洁的配置和快速的开发体验深受开发者喜爱，而Shiro则提供了全面的...
Springboot整合Shiro的代码实例
08-25
Springboot 整合 Shiro 的代码实例 Springboot 整合 Shiro 的代码实例是指在 Springboot 项目中集成 Shiro 框架来实现身份验证和授权管理的过程。Shiro 是一个功能强大且灵活的身份验证和授权框架，可以帮助开发者...
springboot整合shiro使用心得
zm9898的博客
04-09 231
是是是
一个springboot整合shiro小demo的学习分享及心得
weixin_39274753的博客
12-13 816
前言 最近学习了一个18年黑马springboot整合shiro的demo，比之前看的shiro学习视频感觉更容易理解一些，故作分享。之前在尚硅谷看过的视频，是shiro与spring整合，用的是xml配置方式，跟现在流行使用springboot的开发方式略有不同，因此黑马的此视频更容易让人看懂。当然，黑马跟尚硅谷相比，前者符合实际容易理解，后者涉及到更多shiro的功能，建议都看。 ps：本...
shiro权限学习（结合Spring框架）
JAVA & HTML
07-23 106
shiro权限学习初级入门环境配置拦截和验证登录加入角色管理shiro前端的应用，页面显示 初级入门 环境配置 <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core --> <dependency> <groupId>org.apache...
Shiro学习总结(SpringBoot与Shiro的整合使用)
初心不忘、始终方得
04-01 1161
总结SpringBoot项目中如何使用Shiro进行认证与授权。
spring-boot集成shiro
m0_73228336的博客
09-14 101
spring-boot集成shiro
Shiro（一） Shiro整合SpringBoot快速开发
Hello World!
09-01 676
Shiro是apache旗下的一个开源的java安全框架，它将软件系统的安全认证和权限管理相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等，组成了一个通用的安全认证框架。记住一点，Shiro 不会去维护用户、维护权限，这些需要我们自己去设计 / 提供，然后通过相应的接口注入给 Shiro 即可...
SpringBoot整合Shiro(仅测试认证)
心有—林夕的博客
08-11 326
SpringBoot整合Shiro(仅测试认证)
SpringBoot:集成Shiro之INI认证篇
得不到的永远是骚栋.
01-21 708
前言 上一篇SpringBoot:集成Shiro之简述篇中,我们简述了Shiro的基本概念以及Shiro的内部流程方式.下面我先简述一下本篇博客的基本内容以及使用场景. 本篇博客主要是讲 在SpringBoot 2.0 中集成Shiro,使用INI文件的形式完成登录认证(只认证非授权),使用场景只应对较少的用户的系统,而且账号密码为固定. 集成环境 : Mac   |   JDK 1.8   |   SpringBoot 2.0 #####.
Springboot 整合Shiro 轻量级权限框架，从数据库设计开始带你快速上手shiro
默默不代表沉默
04-26 2504
前言 shiro是一个轻量级的权限框架，该篇我将会从0到1快速教大家搭建出一套包含角色，权限登录校验的项目。 就算你没了解过，也能学会。跟着我把代码敲一遍，这个项目就是属于你的。 该篇文章比较啰嗦，篇幅较长，如果不是入门的初学者大可不必从头开始阅读（我一般的教程都会以从零开始的方式，所以都比较啰嗦）。 正文 数据库的准备（Mysql）： 在这是实践的案例里面，数据库表三...
【Shiro权限管理】10.Shiro为密码加盐
热门推荐
程序猿之洞
11-20 3万+
上一篇我们提到了使用Shiro为密码进行MD5加密，这次来说一下密码加盐的问题。 当两个用户的密码相同时，单纯使用不加盐的MD5加密方式，会发现数据库中存在相同结构的密码， 这样也是不安全的。我们希望即便是两个人的原始密码一样，加密后的结果也不一样。 如何做到呢？其实就好像炒菜一样，两道一样的鱼香肉丝，加的盐不一样，炒出来的味道就不一样。 MD5加密也是一样，需要进行盐值加密。 在之
springboot 整合 shiro
最新发布
08-20
- *1* *2* *3* [SpringBoot之整合Shiro(最详细)](https://blog.csdn.net/m0_67392273/article/details/125243717)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值