Shiro 详细教程（集各教程内容为一体）

张学徒

已于 2023-07-24 22:41:57 修改

阅读量2k

点赞数

分类专栏： SpringBoot 文章标签： java spring boot spring shiro

于 2022-05-20 00:52:51 首次发布

本文链接：https://blog.csdn.net/qq_37280924/article/details/124875201

版权

SpringBoot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在参考中发现了《Apache Shiro 参考手册》，强烈建议参看学习。

建议看完之后配合 Shiro保姆级教程学习，他的内容介绍不多，但代码实现过程很完整

Shiro 简介

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

首先创建一个 SpringBoot 项目，并在 pom.xml 文件中引入如下会用到的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>shiro</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shiro</name>
    <description>shiro</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>

        <!-- 导入shiro和spring整合依赖 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>

    </dependencies>


</project>

resources 文件夹下创建 shiro.ini 文件

[users]
zhangsan=123
lisi=123
wangwu=123

测试 Shiro

@Test
public void test01() {
	// 创建安全管理器，设置它的 Realm
	DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
	defaultSecurityManager.setRealm(new IniRealm("classpath:shiro.ini"));
	//将安装工具类中设置默认安全管理器
	SecurityUtils.setSecurityManager(defaultSecurityManager);
	//获取主体对象
	Subject subject = SecurityUtils.getSubject();
	//创建token令牌
	UsernamePasswordToken token = new UsernamePasswordToken("xiaochen1", "123");
	try {
		subject.login(token);//用户登录
		System.out.println("登录成功~~");
	} catch (UnknownAccountException e) {
		e.printStackTrace();
		System.out.println("用户名错误!!");
	}catch (IncorrectCredentialsException e){
		e.printStackTrace();
		System.out.println("密码错误!!!");
	}

}

在这个测试中，我们可以把 ini 当做是个账号的数据库，UsernamePasswordToken token = new UsernamePasswordToken("xiaochen1", "123"); 这一行看作是用户登陆时发来的账号和密码

subject.login(token); 这里进行登陆，开始进行验证上面的 token，这时设置的 IniRealm 对象会查找数据库（当前是 shiro.ini 文件）里是否有匹配的账号，然后验证密码，如果没有报错就是登陆成功，报错那就是不对。

该方法主要执行以下操作:

检查提交的进行认证的令牌信息
根据令牌信息从数据源(通常为数据库)中获取用户信息
对用户信息进行匹配验证。
验证通过将返回一个封装了用户信息的AuthenticationInfo实例。
验证失败则抛出AuthenticationException异常信息。

以下是几种出现的错误：

UnknownAccountException (账号错误/没有账号)
IncorrectCredentialsException (密码错误)
DisabledAccountException（帐号被禁用）
LockedAccountException（帐号被锁定）
ExcessiveAttemptsException（登录失败次数过多）
ExpiredCredentialsException（凭证过期）等

上面代码运行过程：

上边的程序使用的是读取本地 ini 文件的方式进行测试进行验证判断用户名和密码是否正确，但正式开发中是不能用这种的，都需要从数据库中读取对应登陆的用户的信息，所以需要自定义 Realm 处理这些逻辑，以及添加更多样的操作。

Subject 即主体，外部应用与 subject 进行交互，subject 记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。 Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

Realm 即领域，相当于 datasource 数据源，SecurityManager 进行安全认证需要通过 Realm 获取用户权限数据，比如：如果用户身份数据在数据库那么 Realm 就需要从数据库获取用户身份信息。就是在 Realm 里写认证和授权逻辑的，执行的时候会执行 Realm 里的认证和授权逻辑。

注意：不要把 Realm 理解成只是从数据源取数据，在 Realm 中还有认证授权校验的相关的代码。

一般在真实的项目中，我们不会直接实现 Realm 接口，也不会直接继承最底层的功能贼复杂的 IniRealm。我们一般的情况就是直接继承 AuthorizingRealm，能够继承到认证与授权功能。它需要强制重写两个方法：doGetAuthenticationInfo，doGetAuthorizationInfo

[

Shiro 提供的 Realm 体系较为复杂，一般我们为了使用 Shiro 的基本目的就是：认证、授权。可以看以下 SimpleAccountRealm 的部分源码中的两个方法。授权（doGetAuthorizationInfo）、认证（doGetAuthenticationInfo）。两部分的源码：

public class SimpleAccountRealm extends AuthorizingRealm {
		//.......省略
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        SimpleAccount account = getUser(upToken.getUsername());

        if (account != null) {

            if (account.isLocked()) {
                throw new LockedAccountException("Account [" + account + "] is locked.");
            }
            if (account.isCredentialsExpired()) {
                String msg = "The credentials for account [" + account + "] are expired";
                throw new ExpiredCredentialsException(msg);
            }

        }

        return account;
    }

    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = getUsername(principals);
        USERS_LOCK.readLock().lock();
        try {
            return this.users.get(username);
        } finally {
            USERS_LOCK.readLock().unlock();
        }
    }
}

上面就是他的一个认证授权时的逻辑，我们可以自定义一个 UserRealm，以实现更复杂更强大的认证、授权逻辑。

public class UserRealm extends AuthorizingRealm {
    //授权方法（访问不同的 controller 里的接口时进行授权）
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
		// 这个 username 是下面 doGetAuthenticationInfo 方法 return 的对象的第一个参数的值
        final String username = (String) principalCollection.getPrimaryPrincipal();
        System.out.println("执行授权：授权的用户名 " + username);

        final SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        // 查询设置用户的权限 permission（下面假装是数据库查询到的数据）
        Set<String> permissions = new HashSet<>();
        permissions.add("auth:add_user");
        permissions.add("auth:update_user");
        info.setStringPermissions(permissions);

        // 查询设置用户的角色 Role（下面假装是数据库查询到的数据）
        Set<String> roles = new HashSet<>();
        roles.add("管理员");
        info.setRoles(roles);

        return info;
    }

    //认证方法，在登陆的时候会进行验证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行认证");
        final UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        
		/* 
		//按数据库查询应该是以下代码，但为了方便起见，后面的写个假数据
		User user = userService.findUser(token.getUsername());
		if(user != null){
			// 当前 Realm 中的 doGetAuthorizationInfo 方法那个参数就是这个第一个参数，保存了当前用户信息
		    return new SimpleAuthenticationInfo(
                    user,
                    user.getPassword(),
                    this.getName()
            );
		}
        */

		// 数据库查询用户名和密码（这里假作已经查询到了结果）
        String name = "zhangsan";
        String password = "123";
        if (name.equals(token.getUsername())) {
			// new SimpleAuthenticationInfo 的时候会自动校验密码
            return new SimpleAuthenticationInfo(
                    token.getPrincipal(),
                    password,
                    this.getName()
            );
        }

        return null;
    }
}

测试

@Test
public void test01() {
	// 创建安全管理器，设置它的 Realm
	final DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
	defaultSecurityManager.setRealm(new UserRealm());
	// 设置处理认证和授权的安全管理器
	SecurityUtils.setSecurityManager(defaultSecurityManager);

	final Subject subject = SecurityUtils.getSubject();
	// 前端发送来的账号和密码生成的通行令牌，用来让 Realm 的 doGetAuthenticationInfo 方法里执行认证过程
	UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
	try {
		subject.login(token);
		
		// 测试验证授权
		boolean result =  subject.isPermitted("auth:add_usera");
        System.out.println(result);
        
	} catch (UnknownAccountException e) {
		e.printStackTrace();
		System.out.println("用户名错误!!");
	} catch (IncorrectCredentialsException e) {
		e.printStackTrace();
		System.out.println("密码错误!!!");
	}
}

上面运行过程

配置 Shiro

下面开始写 Controller 层逻辑需要用到的类。

创建 ShiroConfig，配置 shiro 的类：

import com.example.shirotest.common.UserRealm;	// 引用自定义的 UserRealm
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Shiro
 *
 * @author z
 * @datetime 2022-5-16
 */
@Configuration
public class ShiroConfig {

    /**
     * 创建 Realm，bean会让方法返回的对象放入到spring的环境，以便使用
     */
    @Bean(name = "userRealm")
    public UserRealm getRealm() {
        return new UserRealm();
    }

    /**
     * @Qualifier 注释指定注入 Bean 的名称，用来消除歧义的
     */
    @Bean(name = "defaultWebSecurityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(userRealm);
        return defaultWebSecurityManager;
    }

    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("defaultWebSecurityManager") DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //设置一个安全管理器来关联 SecurityManager
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        // 默认登陆界面
        shiroFilterFactoryBean.setLoginUrl("/loginPage");

        // 设置权限（非注解方式设置对应 url 的权限）
        // 注意要用 LinkedHashMap 遍历列表时时候按顺序进行匹配判断 URL
        // 所以下面的 /** 要放在最后，否则如果放在第一个则所有的 URL 都
        // 可以被匹配到，那么之后的就失效了
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/loginPage", "anon");
        filterMap.put("/user/login", "anon");

        filterMap.put("/add", "perms[user:add, admin]");
        filterMap.put("/update", "perms[user:update]");

        filterMap.put("/**", "authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

        return shiroFilterFactoryBean;
    }

    /**
     *  开启Shiro的注解 (如@RequiresRoles,@RequiresPermissions)
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }
}

上面的 ShiroFilterFactoryBean 方法中主要主要配置接口的角色权限，确定接口由哪些角色或者哪些权限的用户可以访问。至于 shiro 是怎么知道当前用户是否具有某个角色或权限需要用到后面的 doGetAuthorizationInfo() 方法。

Filter	解释
`anon`	无参，开放权限，可以理解为匿名用户或游客
`authc`	无参，需要认证
`user`	无参，表示必须存在用户，当登入操作时不做检查
`perms[user]`	参数可写多个，表示需要某个或某些权限才能通过，多个参数时写 `perms["user:add, admin"]`，当有多个参数时必须每个参数都通过才算通过
`roles[admin]`	参数可写多个，表示是某个或某些角色才能通过，多个参数时写 `roles["admin, user"]`，当有多个参数时必须每个参数都通过才算通过

Shiro内置的 FilterChain

Filter Name	Class
anon	org.apache.shiro.web.filter.authc.AnonymousFilter
authc	org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic	org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms	org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port	org.apache.shiro.web.filter.authz.PortFilter
rest	org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles	org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl	org.apache.shiro.web.filter.authz.SslFilter
user	org.apache.shiro.web.filter.authc.UserFilter

anon: 所有url都都可以匿名访问
authc: 需要认证才能进行访问
user: 配置记住我或认证通过可以访问

Shiro 权限字符串：

组成规则
在Shiro中使用权限字符串必须按照Shiro指定的规则。

权限字符串组合规则为：“资源类型标识符:操作:资源实例标识符”

资源类型标识符：一般会按模块，对系统划分资源。比如user模块，product 模块，order模块等，对应的资源类型标识符就是：user，product，order。
操作：一般为增删改查（create，delete，update，find），还有 * 标识统配。
资源实例标识符：如果Subject控制的是资源类型，那么资源实例标识符就是 “*” ；如果Subject控制的是资源实例，那么就需要在资源实例标识符就是该资源的唯一标识（ID等）。

示例

*:*:* 表示 Subject 对所有类型的所有实例有所有操作权限，相当于超级管理员。
user:create:* 表示 Subject 对 user 类型的所有实例有创建的权限，可以简写为：user:create。
user:update:001 表示 Subject 对 ID 为 001 的 user 实例有修改的权限。
user:*:001 表示 Subject 对 ID 为 001 的 user 实例有所有权限。

Filter Chain定义说明：

1、一个URL可以配置多个Filter，使用逗号分隔
2、当设置多个过滤器时，全部验证通过，才视为通过
3、部分过滤器可指定参数，如perms，roles

上面的自定义的 UserRealm 和 ShiroConfig 创建的步骤你可以把它算作一个固定的套路，只要使用 Shiro 就难以避免，必须要创建这两个类，以及实现其中的方法。

MD5 加密

我们创建一个 MD5Utils 工具类，对密码进行加密，加密后的密码破解难度是“不可能破解出来”，即便黑客获取到数据库，也无法知道具体密码

import org.apache.shiro.crypto.hash.Md5Hash;

public class MD5Utils {

    /**
     * 加密盐值
     */
    public static final String SALT = "^3&5as@9.[km0";

    /**
     * 密码进行MD5加密
     */
    public static String md5Password(String password) {
        // 加密 1024 次
        Md5Hash md5Hash = new Md5Hash(password, SALT, 1024);
        return md5Hash.toHex();
    }

}

用户注册的时候，我们对他们的密码进行加密保存到数据库中，
那么在提交用户输入原始的密码的时候，我们需要进行加密跟我们已经保存的加密后的密码进行匹配，如果两个加密后的密码相同，那自然两个密码都是一样的

对测试类中的 token 添加加密，也就是对发来的密码进行 MD5 加密

UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", MD5Utils.md5Password("123"));

UserRealm 中的 doGetAuthenticationInfo() 因为我们写的假数据，所以也要改一下，改为如下：

@Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行认证");

        // 数据库查询用户名和密码（这里假作已经查询到了结果）
		// 如果是从数据库查找到的则不用进行 MD5Utils.md5Password 这个操作，因为数据库里已经加过密了
		// 这里因为这是我们手动设置的假数据，所以需要 md5 加密一下
        String name = "zhangsan";
        String password = MD5Utils.md5Password("123");

        final UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        if (name.equals(token.getUsername())) {
            // new SimpleAuthenticationInfo 的时候会自动校验密码
            return new SimpleAuthenticationInfo(
                    token.getPrincipal(),
                    password,
                    this.getName()
            );
        }

        return null;
    }

权限注解

注：shiro 提供了相应的注解用于权限控制，如果使用这些注解就需要使用 aop 的功能来进行判断。shiro 提供了 spring aop 集成，用于权限注解的解析和验证

（1）@RequiresAuthentication ：方法在访问或调用时，当前 Subject 必须在当前 session 中已经过认证。表示当前 Subject 已经通过 login 进行了身份验证；即 Subject.isAuthenticated() 返回 true。

（2）@RequiresUser：表示当前 Subject 已经身份验证或者通过记住我登录的，才能访问或调用被该注解标注的类，实例，方法。

（3）@RequiresGuest ：表示当前 Subject 没有身份验证或通过记住我登录过，即是游客身份。使用该注解标注的类，实例，方法在访问或调用时，当前 Subject 可以是 guest 身份，不需要经过认证或者在原先的 session 中存在记录。

（4）@RequiresRoles(value={"admin", "user"}, logical= Logical.AND) 当前 Subject 必须拥有所有指定的角色时，才能访问被该注解标注的方法。如果当天 Subject 不同时拥有所有指定角色，则方法不会执行还会抛出 AuthorizationException 异常。

（5）@RequiresPermissions (value={"user:a", "user:b"}, logical= Logical.OR) ：表示当前 Subject 需要权限 user:a 或 user:b。当前 Subject 需要拥有某些特定的权限时，才能执行被该注解标注的方法。如果当前 Subject 不具有这样的权限，则方法不会被执行。

Shiro 的认证注解处理是有内定的处理顺序的，如果有个多个注解的话，前面的通过了会继续检查后面的，若不通过则直接返回，处理顺序依次为（与实际声明顺序无关）：

RequiresRoles
RequiresPermissions
RequiresAuthentication
RequiresUser
RequiresGuest

例如：你同时声明了 @RequiresRoles 和 @RequiresPermissions，那就要求拥有此角色的同时还得拥有相应的权限。

@RequiresRoles

可以用在 Controller 或者方法上。可以多个 roles，多个roles 时默认逻辑为 AND 也就是所有具备所有 role 才能访问。

示例：

//属于user角色
@RequiresRoles("user")

//必须同时属于user和admin角色
@RequiresRoles({"user","admin"})

//属于user或者admin之一;修改logical为OR 即可
@RequiresRoles(value={"user","admin"},logical=Logical.OR)

@RequiresPermissions

和 @RequiresRoles 类似。示例：

//符合index:hello权限要求
@RequiresPermissions("index:hello")

//必须同时复核index:hello和index:world权限要求
@RequiresPermissions({"index:hello","index:world"})

//符合index:hello或index:world权限要求即可
@RequiresPermissions(value={"index:hello","index:world"},logical=Logical.OR)

@RequiresAuthentication，@RequiresUser，@RequiresGuest

这三个的使用方法一样

@RequiresAuthentication
@RequiresUser
@RequiresGusst

其他例子：

@RequiresPermissions({"file:read", "write:aFile.txt"} )
void someMethod();

要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。

@RequiresRoles({"admin"})
void method();

只有 admin 角色才能访问该方法，其他角色访问将会抛出异常

注意事项

在日常开发时，往往会在 Service 层添加“@Transactional”注解，为的是当 Service 发送数据库异常时，所有数据库操作可以回滚。

当在 Service 层添加“@Transactional”注解后，执行 Service 方法前，会开启事务。此时的 Service 已经是一个代理对象了，此时如果我们将 Shiro 的权限注解加载 Service 层是不合适的，此时需要加到 Controller 层。这是因为不能让 Service 是“代理的代理”，如果强行注入，会发生类型转换异常。

建议看完之后配合 Shiro保姆级教程学习，他的文章中还包含有 SQL 的创建和实现步骤

参考

如有错误，还请指正和建议。

张学徒

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
Shiro 详细教程（集各教程内容为一体）

在参考中发现了《Apache Shiro 参考手册》，强烈建议参看学习。Shiro 简介Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。首先创建一个 SpringBoot 项目，并在 pom.xml 文件中引入如下会用到的依赖 <dependencies> <dependency> <groupId&g
复制链接

扫一扫