Apache Shiro 实战教程与项目案例全集

永不放弃yes

于 2024-09-02 16:15:47 发布

阅读量538

点赞数 3

本文链接：https://blog.csdn.net/weixin_42186387/article/details/141848748

版权

本文还有配套的精品资源，点击获取

简介：本教程通过一系列Apache Shiro相关的项目源代码，旨在帮助开发者深入理解并应用Shiro框架。Shiro提供认证、授权、加密和会话管理等安全功能，适合快速开发小型至中型项目。通过实践示例，学习Shiro核心组件如Subject、Authenticator、Realm、Permission、Role等的实际应用，以及如何进行用户登录验证、权限控制、加密处理和会话管理。此外，教程还包括Shiro与Web应用的集成以及如何在项目中处理安全配置和依赖。跟我学shiro教程对应的所有项目

1. Apache Shiro简介

Apache Shiro是一个全面的Java/Java EE安全框架，用于简化身份验证、授权、加密和会话管理。Shiro旨在为安全需求提供易于理解和使用的API，而不依赖特定的架构风格或后端存储。作为一个应用层的安全框架，Shiro不仅限于Web应用，还适用于独立应用程序、移动应用、分布式服务和其他场合。

从概念上讲，Shiro实现了“谁可以做什么？”这一核心安全问题。Shiro在应用安全方面涵盖了三个主要领域：认证（确认用户身份），授权（允许用户执行操作），和会话管理（管理用户与应用交互）。这些领域构建在Shiro的五大核心组件之上，包括Subject, SecurityManager, Realms, Authenticators, 和 Authorization。

让我们深入探讨这些组件是如何协作以及如何配置Shiro以满足不同的安全需求，从而让应用更加强大和安全。

2. Shiro项目结构介绍

Apache Shiro的项目结构是一个设计精良的安全框架，它提供了全面的身份验证、授权、会话管理、加密等功能。本章将详细介绍Shiro的项目结构，包括核心组件概览、配置方式详解，帮助读者深入理解Shiro如何运作。

2.1 Shiro核心组件概览

Shiro框架中的核心组件包括认证、授权、会话和加密组件。这些组件是构建安全应用的基石。

2.1.1 认证与授权组件

认证组件负责用户身份验证，确保用户身份的真实性。Shiro支持多种认证方法，包括基于表单的认证、JAAS认证和自定义认证。

授权组件负责控制用户访问资源的权限。它提供了一套细粒度的访问控制API，支持基于角色的访问控制（RBAC）。

// 示例代码：实现用户登录认证
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.subject.Subject;

Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("user", "pass");
try {
    subject.login(token);
    // 认证成功
} catch (UnknownAccountException uae) {
    // 未找到用户异常
} catch (IncorrectCredentialsException ice) {
    // 凭证错误异常
} catch (AuthenticationException ae) {
    // 认证异常
}

在上述代码中，我们创建了一个 UsernamePasswordToken 对象，它携带了用户的登录凭证，并交由 Subject 实例去进行登录。 Subject 是Shiro中用于表示当前用户安全上下文的一个核心概念。

2.1.2 加密与会话组件

加密组件提供了密码散列、数据加密等功能。它支持多种算法，并提供了简单的API来实现加密、解密等操作。

会话组件管理用户的会话。在Shiro中，会话是一个高层次的概念，它封装了操作用户会话的所有细节。Shiro为开发者隐藏了底层会话存储的细节。

// 示例代码：进行密码散列加密操作
import org.apache.shiro.crypto.hash.Md5Hash;

Md5Hash hash = new Md5Hash("原始密码", "盐值", 1024);
String hashedPassword = hash.toHex(); // 生成16进制散列值

在上述代码中，我们使用了 Md5Hash 类来创建一个使用MD5算法的散列对象。通过传入原始密码、一个盐值以及迭代次数，我们可以获得一个散列值。这个散列值可以被安全地存储起来，以用于后续的密码验证操作。

2.2 Shiro配置方式详解

配置Shiro通常有三种方式：INI配置文件、Java代码配置和Spring整合Shiro配置。下面将逐一介绍这些配置方式。

2.2.1 INI配置文件解析

INI配置文件是Shiro最简单的配置方式，它通过声明式的配置来完成安全相关的配置。

[main]
# 配置realm
securityManager.realms=$myRealm

[users]
# 用户名和密码，使用逗号分隔
admin = password1, admin

[roles]
# 角色定义
admin = *

在这个示例中，我们配置了一个安全管理器 securityManager ，设置了用户和角色信息。这种方式简单易懂，适合不熟悉Java代码的开发者快速上手。

2.2.2 Java代码配置解析

Java代码配置提供了更大的灵活性和编程控制能力。通过编程方式可以实现复杂的配置逻辑。

// 示例代码：Java代码配置Shiro
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.SimpleAccountRealm;
import org.apache.shiro.realm.Realm;

Realm realm = new SimpleAccountRealm();
realm.addAccount("user", "password", "role1");
SecurityManager securityManager = new DefaultSecurityManager(realm);

// 与Web应用集成
// SecurityUtils.setSecurityManager(securityManager);

在代码中，我们创建了一个 SimpleAccountRealm 实例，并向其中添加了一个用户和角色。然后，我们用这个realm配置了 DefaultSecurityManager 。这允许我们通过编程方式控制安全管理器和realm的配置。

2.2.3 Spring整合Shiro配置

将Shiro与Spring框架整合可以更好地利用Spring的依赖注入和声明式事务等特性。

// 示例代码：Spring配置文件整合Shiro
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;

@Configuration
public class ShiroConfig {

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 配置realm
        securityManager.setRealm(myRealm());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean() {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager());
        // 过滤器配置
        // shiroFilterFactoryBean.getFilterChainDefinitionMap().put("/**", "authc");
        return shiroFilterFactoryBean;
    }
    @Bean
    public Realm myRealm() {
        // 实例化realm
        return new MyRealm();
    }
}

在这个Spring配置类中，我们配置了 SecurityManager 和 ShiroFilterFactoryBean 。ShiroFilterFactoryBean用于定义URL模式与Shiro安全策略的关联。这样，我们就可以利用Spring的强大功能来管理Shiro的安全环境。

2.3 小结

在本章节中，我们详细介绍了Shiro的项目结构，包括它的核心组件和配置方式。我们通过代码示例和配置文件演示了如何进行用户认证、授权、加密和会话管理。此外，我们还探讨了如何将Shiro与Spring框架进行集成，以提供更丰富的功能和更灵活的配置选项。通过这些介绍和实例，读者应该对Shiro有了基本的认识，并能够根据自己的需求选择合适的方式来进行配置和使用。

3. 认证机制实现与案例分析

Shiro的核心特性之一是其认证机制，它允许系统有效地识别和验证用户的身份。认证（Authentication）在Shiro中是通过一系列精心设计的接口和类来实现的。本章将详细介绍Shiro的认证流程，并通过案例分析深入探讨如何在实际项目中应用Shiro的认证功能。

3.1 认证流程详解

3.1.1 用户身份验证过程

在Shiro中，用户身份的验证过程主要通过以下步骤实现：

用户提交认证信息 ：通常，用户会向系统提供用户名和密码等凭据。
收集凭据 ：Shiro通过 Subject 对象获取用户输入的凭据。
创建凭证匹配器 ：Shiro使用 CredentialsMatcher 接口来比对用户提交的凭证和存储在系统中的凭证是否匹配。
执行认证 ：Shiro使用 AuthenticationInfo 对象来封装用户的凭证信息，并通过 AuthenticationStrategy 接口进行认证策略的执行。
认证结果反馈 ：认证成功后，Shiro会将认证信息存储在 SecurityManager 中，失败则抛出异常。

Shiro框架通过 Subject 来进行用户身份验证，以下是一段简单的代码示例，展示了如何使用Shiro进行用户身份验证：

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;

// 获取当前的Subject实例
Subject subject = SecurityUtils.getSubject();

// 创建用户凭证
UsernamePasswordToken token = new UsernamePasswordToken("username", "password");

// 执行登录操作
subject.login(token);

// 判断是否认证成功
if (subject.isAuthenticated()) {
    System.out.println("用户认证成功！");
}

在上述代码中， Subject 对象是通过 SecurityUtils 工具类获取的。然后，创建了一个 UsernamePasswordToken 实例，这代表了用户提交的凭据。调用 subject.login(token) 方法会触发Shiro的认证流程。

3.1.2 认证策略与实践

Shiro提供了多种认证策略，例如：

AtLeastOneSuccessfulStrategy ：至少有一个认证器成功即认证成功。
FirstSuccessfulStrategy ：第一个认证器成功即认证成功。
AllSuccessfulStrategy ：所有认证器都成功才能认证成功。

这些策略可以灵活配置，以满足不同的安全需求。开发者可以在Shiro的配置文件中指定认证策略。

[main]
# 配置认证策略为至少有一个认证器成功即认证成功
authenticator.authenticationStrategy = org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy

或者使用Java配置：

import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy;

// ...

ModularRealmAuthenticator authenticator = new ModularRealmAuthenticator();
authenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());

// ...

3.2 认证案例操作

3.2.1 自定义认证实现

在某些情况下，我们需要实现自定义的认证逻辑来满足特定的需求。下面的示例展示了如何通过自定义 Realm 来实现自定义认证逻辑：

import org.apache.shiro.authc.*;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.subject.PrincipalCollection;

public class CustomRealm extends AuthorizingRealm {

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 授权逻辑
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = upToken.getUsername();

        // 模拟数据库中的用户信息
        if ("admin".equals(username)) {
            // 根据用户名查询用户密码等信息
            String password = "admin123"; // 注意实际应用中密码应加密存储

            // 认证信息中存储的是密码的哈希值，而非明文密码
            return new SimpleAuthenticationInfo(username, password, getName());
        } else {
            return null;
        }
    }
}

在上述代码中，我们创建了一个 CustomRealm 类继承自 AuthorizingRealm 。 doGetAuthenticationInfo 方法中的逻辑是根据用户名来查询用户的密码，实际应用中应该从数据库中查询。如果用户名为"admin"，则返回一个认证信息，其中包含用户名和密码的哈希值。这样，Shiro就会使用我们提供的凭证信息来进行用户认证。

3.2.2 应用中集成Shiro认证

要在实际应用中集成Shiro的认证，我们需要做以下步骤：

引入Shiro依赖 ：在项目的 pom.xml 文件中添加Shiro库的依赖。
配置Shiro安全管理器 ：通过Shiro的配置文件或者Java代码配置 SecurityManager 。
配置登录与登出URL ：在web应用中配置Shiro的过滤器链，指定登录URL和登出URL。
编写登录控制器 ：创建控制器来处理用户的登录请求。

以下是一个简单的Spring Boot整合Shiro认证的配置示例：

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ShiroConfig {

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 配置realm
        securityManager.setRealm(customRealm());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 配置登录和登出URL
        shiroFilterFactoryBean.setLoginUrl("/login");
        shiroFilterFactoryBean.setSuccessUrl("/home");
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

        // 配置过滤器链
        Map<String, String> filterChainDefinitionMap = new HashMap<>();
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/logout", "logout");
        filterChainDefinitionMap.put("/**", "authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    @Bean
    public CustomRealm customRealm() {
        return new CustomRealm();
    }
}

在上述配置中，我们通过 ShiroFilterFactoryBean 来配置了Shiro的过滤器链，并指定登录、登出、未授权等URL。通过 SecurityManager 管理认证和授权， CustomRealm 实现了认证逻辑。

整个Shiro的认证机制实现与案例分析过程，通过理论知识与实际代码示例的结合，使得对认证流程的理解更加透彻。在此基础上，开发者可以更好地利用Shiro来进行安全控制，并在真实的应用场景中实现更加强大和灵活的认证方案。

4. 授权机制实现与案例分析

授权是Shiro安全框架的核心功能之一，其主要作用是控制访问资源的权限。在这一章节中，我们将深入探讨Shiro的授权原理、机制及实践案例，帮助读者更好地理解和应用Shiro的授权功能。

4.1 授权原理及实践

4.1.1 权限检查机制

Shiro的授权机制通过访问控制列表（ACLs），角色和权限的组合来实现。权限检查机制主要涉及到以下几个核心组件：

Subject : 当前与软件交互的用户，可以是用户、第三方服务、定时任务等。
SecurityManager : 作为Shiro的心脏，负责安全操作的协调。
AuthorizationInfo : 包含了用户被授权信息的集合，如角色、权限等。
Permission : 权限的抽象表示，可以是具体的字符串、通配符等。

权限检查流程一般如下：

获取Subject : 通过 SecurityManager 获取当前的 Subject 实例。
判断权限 : 使用 Subject 的 isPermitted 或 checkPermission 方法检查是否有相应的权限。
授权决定 : 如果 Subject 有相应的权限，操作将被允许；否则，将根据配置返回未授权的结果或抛出异常。

4.1.2 角色与权限管理

角色和权限的管理是实施授权策略的关键。一个角色可以分配多个权限，而用户可以被分配一个或多个角色。这一部分我们将展示如何在Shiro中配置角色和权限，以及如何使用它们进行授权。

角色管理

角色通常代表一组权限的集合。在Shiro中，可以定义角色和分配权限的代码如下：

// 角色的定义
SimpleRole role = new SimpleRole("admin");
role.addPermissions("user:create", "user:update");

// 将角色分配给Subject
SecurityUtils.getSubject().getPrincipal().addRole("admin");

权限管理

权限代表了对资源的操作权限。在Shiro中，权限可以是任何字符串，具体取决于你的应用如何解析这些字符串。

// 权限检查示例
Subject subject = SecurityUtils.getSubject();
if (subject.isPermitted("user:create")) {
    // 用户具有创建用户的权限
}

4.2 授权案例应用

4.2.1 基于注解的权限控制

Shiro提供了注解的方式，允许开发者在代码中直接声明权限控制逻辑。以下是一个基于注解实现权限控制的案例：

@RequiresPermissions("user:create")
public void createUser(User user) {
    // 创建用户逻辑
}

在这个示例中，只有拥有“user:create”权限的用户才能调用 createUser 方法。如果当前用户不具有此权限，Shiro会抛出一个 UnauthorizedException 异常。

4.2.2 动态权限更新处理

在真实的应用中，角色和权限可能会动态变化。Shiro提供了监听器机制，当权限变更时，可以及时更新授权信息。

// 注册权限变更监听器
Realm realm = securityManager.getRealm();
realm.addAuthorizationListener(new AuthorizationListener() {
    @Override
    public void onAuthorizationChanged(Set<PrincipalCollection> principals) {
        // 处理权限变更逻辑
        // 例如：重新加载用户权限
    }
});

在上面的代码中，每当角色或权限信息发生变化时，监听器的 onAuthorizationChanged 方法将被调用。

为了更好的理解，我们下面通过一个表格来对比角色与权限管理：

| 功能 | 角色管理 | 权限管理 | | --- | --- | --- | | 目的 | 代表一组权限的集合 | 代表对资源的操作权限 | | 使用场景 | 适用于分配给用户一组固定的权限组合 | 适用于定义可访问的具体资源和操作 | | 实现方式 | 通过定义角色并分配权限字符串 | 通过定义权限字符串并分配给角色或用户 | | 动态性 | 相对静态，适合经常不变的权限组合 | 可以频繁更新，适合表示具体的操作 |

通过以上章节的介绍，Shiro的授权机制与实践应用已经详细呈现。在下一章节中，我们将继续深入探讨Shiro的加密工具应用与案例分析。

5. 加密工具应用与案例分析

5.1 Shiro加密基础

5.1.1 加密解密原理

加密解密是信息安全领域中的核心概念，目的是为了保护数据的安全性。在Shiro框架中，提供了多种加密工具类，支持不同的加密算法，以确保数据在传输和存储过程中的安全性。

Shiro 使用散列算法来处理密码存储，散列算法是一种单向加密过程，意味着它是不可逆的。即使攻击者获取了散列值，也很难（理论上不可能）解密出原始数据。散列算法通常包含以下特点：

单向性 ：只能从原始数据到散列值，不能反向操作。
固定长度输出 ：无论输入多长，输出的散列值长度固定。
雪崩效应 ：即使输入数据有微小变化，输出的散列值也会发生巨大变化。

Shiro内建了对MD5、SHA-1、SHA-256等散列算法的支持，并且通过其 Hash 接口提供了这些散列算法的实现。

5.1.2 密码存储与校验策略

在用户认证过程中，往往需要将用户密码进行散列处理后存储在数据库中。当用户登录时，Shiro会将输入的明文密码进行同样的散列处理，并与数据库中存储的散列值进行比对。

为了提高安全性，Shiro还引入了盐值（salt）的概念，即在密码的散列过程中加入一个随机字符串。这样即便是两个用户使用了相同的密码，由于盐值不同，散列出来的结果也是不同的，这极大地增加了密码破解的难度。

此外，Shiro还支持迭代散列，即将散列算法应用多次（如1024次）以增加破解的难度。

5.2 加密实践案例

5.2.1 实现自定义加密算法

Shiro不仅提供内置的加密算法，还支持用户自定义加密算法。以下是一个简单的自定义加密算法实现示例：

public class CustomHashStrategy implements HashStrategy<String> {

    @Override
    public int iterations() {
        // 迭代次数可以根据实际情况调整
        return 1024;
    }

    @Override
    public Object hash(Object plaintext, Object salt, int iterations, String algorithmName) {
        // 使用SHA-256算法，并加入盐值
        String toHash = plaintext.toString() + salt.toString();
        try {
            MessageDigest digest = MessageDigest.getInstance(algorithmName);
            byte[] encodedhash = digest.digest(toHash.getBytes(StandardCharsets.UTF_8));
            return convertToHex(encodedhash);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("Failed to obtain hashing algorithm", e);
        }
    }

    private String convertToHex(byte[] data) {
        StringBuilder buf = new StringBuilder();
        for (byte b : data) {
            int halfbyte = (b >>> 4) & 0x0F;
            int two_halfs = 0;
            do {
                buf.append((0 <= halfbyte) && (halfbyte <= 9) ? (char) ('0' + halfbyte) : (char) ('a' + (halfbyte - 10)));
                halfbyte = b & 0x0F;
            } while (two_halfs++ < 1);
        }
        return buf.toString();
    }
}

在Shiro配置中，就可以将这个自定义策略实例化并使用。

5.2.2 加密模块在应用中的部署

在应用中部署加密模块，首先需要在Shiro的配置中启用加密策略，然后在认证过程中使用该策略对用户密码进行散列处理。以下是在Shiro配置中启用自定义散列策略的示例：

// 实例化SecurityManager
DefaultSecurityManager securityManager = new DefaultSecurityManager();
securityManager.setRealm(myRealm);

// 实例化自定义散列策略
HashService hashService = new SimpleHashService();
hashService.setHashStrategy(new CustomHashStrategy());
securityManager.setHashService(hashService);

// 将securityManager配置到ShiroFilter
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);

通过以上步骤，我们就可以在Shiro应用中部署和使用自定义的加密策略，从而提高系统的安全性。

本文还有配套的精品资源，点击获取