SpringBoot + Shiro 详解+使用案列_springboot shiro realm 详解-CSDN博客

本文链接：https://blog.csdn.net/zkcJava/article/details/119893641

本文详细介绍了Apache Shiro的基础配置、多Realm认证、Redis缓存、自定义认证器和统一异常处理，助您快速掌握Shiro在Java应用中的身份安全与权限管理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

初始shiro

文章目录

初始shiro
一、shiro是什么？
二、ShiroConfig配置
三、测试代码案例
四、自定义认证器进行多Realm认证
五、统一返回处理
六、统一异常处理
七、常见问题处理

一、shiro是什么？

1.shiro简介

官网地址：shiro官网
Apache Shiro是一个强大且易用的Java安全框架，用来进行身份验证、授权、密码和会话管理。使用Shiro的易于理解API,你可以快速、轻松地获取任何应用程序，从最小的移动应用程序到最大的网络和企业应用程序

2.结构分析

shiro架构图：官网架构图

(1)从外部整体看shiro框架

即从应用程序角度来看，shiro是如何来进行工作的。
在这里插入图片描述

api	说明
Subject	主体，应用代码直接交互的对象是 Subject，也就是说 Shiro 的对外 API 核心就是 Subject , 代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
ShiroSecurityManager	安全管理器，即所有与安全有关的操作都会与SecurityManager交互且它管理着所有Subject;可以看出它是Shiro的核心，它负责与后面介绍的其它组件进行交互，可以把它看成DispathcherServlet前端控制器
Realm	域，Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource,即安全数据源

也就是说最简单的一个Shiro应用：
1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。
从以上也可以看出，Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入。

(2)从外部整体看shiro框架

在这里插入图片描述

组件	说明
Subject	主体，主体可以是任何可以与应用交互的“用户”
SecurityManager	相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理
Authenticator	认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了
Authrizer	授权器或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能
Realm	可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；
SessionManager	如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）
SessionDAO	DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能
CacheManager	缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能
Cryptography	密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的

(3)shiro名词解释

在这里插入图片描述

(4)shiro默认过滤器

当 Shiro 被运用到 web 项目时，Shiro 会自动创建一些默认的过滤器对客户端请求进行过滤。比如身份验证、授权等相关的操作。

过滤器	对应的 Java 类
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
logout	org.apache.shiro.web.filter.authc.LogoutFilter
noSessionCreation	org.apache.shiro.web.filter.session.NoSessionCreationFilter

(5)对过滤器解释说明

/admins/**=anon # 表示该 uri 可以匿名访问
/admins/**=auth # 表示该 uri 需要认证才能访问
/admins/**=authcBasic # 表示该 uri 需要 httpBasic 认证
/admins/**=perms[user:add:] # 表示该 uri 需要认证用户拥有 user:add: 权限才能访问
/admins/**=port[8081] # 表示该 uri 需要使用 8081 端口
/admins/**=rest[user] # 相当于 /admins/=perms[user:method]，其中，method 表示 get、post、delete 等
/admins/**=roles[admin] # 表示该 uri 需要认证用户拥有 admin 角色才能访问
/admins/**=ssl # 表示该 uri 需要使用 https 协议
/admins/**=user # 表示该 uri 需要认证或通过记住我认证才能访问
/logout=logout # 表示注销,可以当作固定配置

注意：
anon，authcBasic，auchc，user 是认证过滤器。
perms，roles，ssl，rest，port 是授权过滤器

(6)常见异常

shiro全局异常：org.apache.shiro.ShiroException
shiro常见异常分为两大类：

1. AuthencationException:

AuthenticationException 异常是Shiro在登录认证过程中，认证失败需要抛出的异常。 AuthenticationException包含以下子类：

1.1 CredentitalsException 凭证异常及子类

IncorrectCredentialsException 不正确的凭证
ExpiredCredentialsException 凭证过期

1.2 AccountException 账号异常及子类

ConcurrentAccessException 并发访问异常（多个用户同时登录时抛出）
UnknownAccountException 未知的账号
ExcessiveAttemptsException 认证次数超过限制
DisabledAccountException 禁用的账号
LockedAccountException 账号被锁定

1.3 UnsupportedTokenException 使用了不支持的Token

2. AuthorizationException:

UnauthorizedException:抛出对请求的操作或对请求的资源的访问是不允许的
UnanthenticatedException:当未完成成功认证时，执行授权操作时引发异常

(7)shiro常见标签

在这里插入图片描述

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
      <!--xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro">-->
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<!--
<shiro:guest></shiro:guest>  判断用户是否是游客身份，如果是，则显示此标签内容
<shiro:user></shiro:user>  判断用户是否是登录认证之后的，如果是，则显示此标签内容
<shiro:principal></shiro:principal> 获取当前登录的用户信息
-->

<shiro:guest>
  欢迎游客访问，<a th:href="@{/toLogin}">登录</a>
</shiro:guest>
<!--从session中判断值-->
<!--<div th:if="${session.loginUser}!=null"></div>-->

<shiro:user>
  用户[<h th:text="${session.loginUser.username}"></h>]欢迎您， <a th:href="@{/users/logout}">退出</a>
</shiro:user>

<p th:text="${msg}"></p>
<hr>
<div shiro:hasPermission="user:add">
<a th:href="@{/user/add}">add</a>
</div>
<div shiro:hasPermission="user:update">
<a th:href="@{/user/update}">update</a>
</div>
</body>
</html>

二、ShiroConfig配置

1.配置Realm及多Realm的认证策略

多Realm认证策略: AuthenticationStrategy
• AuthenticationStrategy 接口的默认实现：
• FirstSuccessfulStrategy：只要有一个 Realm 验证成功即可，只返回第一个 Realm 身份验证成功的认证信息，其他的忽略；
• AtLeastOneSuccessfulStrategy：只要有一个Realm验证成功即可，和 FirstSuccessfulStrategy 不同，将返回所有Realm身份验证成功的认证信息；
• AllSuccessfulStrategy：所有Realm验证成功才算成功，且返回所有 Realm身份验证成功的认证信息，如果有一个失败就失败了。 • ModularRealmAuthenticator 默认是 AtLeastOneSuccessfulStrategy 策略
第一种写法：

 /**
     * 代表系统资源
     * @return
     */
    @Bean
    public UserRealm userRealm() {
   
   
        UserRealm userRealm = new UserRealm();
        userRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return userRealm;
    }

    /**
     * 代表系统资源
     * @return
     */
    @Bean
    public MobileRealm mobileRealm() {
   
   
        MobileRealm mobileRealm = new MobileRealm();
        mobileRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return mobileRealm;
    }


    /**
     * 流程控制
     * @param userRealm
     * @return
     */
    @Bean
    public DefaultWebSecurityManager securityManager(UserRealm userRealm,MobileRealm mobileRealm) {
   
   
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        //多Realm 配置认证策略
        //AllSuccessfulStrategy所有realm都认证通过
        //FirstSuccessfulStrategy 第一个Realm认证成功，后面的realm再不认证
        //AtLeastOneSuccessfulStrategy 至少有一个realm认证通过
        securityManager.setRealms(Arrays.asList(userRealm,mobileRealm));

        //配置多Realm认证策略
        ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
        modularRealmAuthenticator.setRealms(Arrays.asList(userRealm,mobileRealm));
        securityManager.setAuthenticator(modularRealmAuthenticator);

        return securityManager;
    }

第二种写法：

/***
* 配置Realm
* */
@Bean
Realm userRealm() {
   
   
    TestRealm userRealm = new TestRealm();
    return userRealm;
}
/***
 * 测试realm
 * @return
 */
@Bean
Realm testRealm() {
   
   
    return new TestRealm();
}
 
/**
 * 多Realm认证策略
 * @return
 */
@Bean
Authenticator authenticator() {
   
   
    ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
    //使用一个通过验证即可通过验证的方式
    modularRealmAuthenticator.setAuthenticationStrategy(atLeastOneSuccessfulStrategy());
    return modularRealmAuthenticator;
}
/**
 * 所有reaml全都通过才算认证通过作为策略
 * @return
 */
@Bean
AuthenticationStrategy allSuccessfulStrategy() {
   
   
    AllSuccessfulStrategy allSuccessfulStrategy = new AllSuccessfulStrategy();
    return allSuccessfulStrategy;
}
/**
 * 所有reaml一个通过就算认证通过作为策略
 * @return
 */
@Bean
AuthenticationStrategy atLeastOneSuccessfulStrategy() {
   
   
    AtLeastOneSuccessfulStrategy atLeastOneSuccessfulStrategy = new AtLeastOneSuccessfulStrategy();
    return atLeastOneSuccessfulStrategy;
    }

2.配置RedisCacheManager和SeeionManager

2.1 引入依赖

<!-- 使用RedisProperties配置类-->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- shiro+redis 做session和缓存控制-->
<dependency>
    <groupId>org.crazycake</groupId>
    <artifactId>shiro-redis</artifactId>
    <version>3.3.1</version>
</dependency>

2.2 ShiroConfig中配置

 @Bean
 public RedisManager redisManager(){
   
   
      RedisManager redisManager = new RedisManager();
      JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
      //连接池最大量20，并发特别大时
      jedisPoolConfig.setMaxTotal(redisProperties.getJedis().getPool().getMaxActive());
      //连接池的最大剩余量15个，并发不大
      jedisPoolConfig.setMaxIdle(redisProperties.getJedis().getPool().getMaxIdle());
      //连接池初始就10个
      jedisPoolConfig.setMinIdle(redisProperties.getJedis().getPool().getMinIdle());
      JedisPool jedisPool = new JedisPool(jedisPoolConfig,redisProperties.getHost(),redisProperties.getPort(),2000,redisProperties.getPassword());
      redisManager.setJedisPool(jedisPool);
      return redisManager;
  }
/**
   * 缓存控制:shiro+redis实现
   * @param redisManager
   * @return
   */
  @Bean
  public RedisCacheManager redisCacheManager(RedisManager redisManager){
   
   
      RedisCacheManager redisCacheManager = new RedisCacheManager();
      redisCacheManager.setRedisManager(redisManager);
      //针对不同用户进行缓存
      redisCacheManager.setPrincipalIdFieldName("user");
      //用户权限信息缓存时间 1800
      redisCacheManager.setExpire(1800);
      return redisCacheManager;
  }

  /**
   * SessionDAO的作用是为Session提供CRUD并进行持久化的一个shiro组件
   * @param redisManager
   * @return
   */
  @Bean
  public RedisSessionDAO redisSessionDAO(RedisManager redisManager){
   
   
      RedisSessionDAO sessionDAO = new RedisSessionDAO();
      sessionDAO.setRedisManager(redisManager);
      sessionDAO.setSessionIdGenerator(sessionIdGenerator());
      //session在redis中保存的时间 1800
      sessionDAO.setExpire(1800);
      return sessionDAO;
  }

  @Bean
  public DefaultWebSessionManager sessionManager(RedisSessionDAO redisSessionDAO){
   
   
      DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
      sessionManager.setSessionDAO(redisSessionDAO);

      //全局会话超时时间（单位毫秒），默认30分钟1800000
      sessionManager.setGlobalSessionTimeout(600000);
      //是否开启删除无效的session对象  默认为true
      sessionManager.setDeleteInvalidSessions(true);
      //是否开启定时调度器进行检测过期session 默认为true
      sessionManager.setSessionValidationSchedulerEnabled(true);
      //设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话 默认为1个小时
      sessionManager.setSessionValidationInterval(3600000);
      //取消url 后面的 JSESSIONID
      sessionManager.setSessionIdUrlRewritingEnabled(false);
      return sessionManager;
  }

3.配置securityManager

/**
     * 流程控制器
     * @param userRealm
     * @return
     */
    @Bean
    public DefaultWebSecurityManager securityManager(UserRealm userRealm,
                                                     MobileRealm mobileRealm,
                                                     CookieRememberMeManager rememberMeManager,
                                                     RedisCacheManager redisCacheManager,
                                                     DefaultWebSessionManager sessionManager,
                                                     ModularRealmAuthenticator modularRealmAuthenticator,
                                                     MyModularRealmAuthenticator myModularRealmAuthenticator
                                                     ) {
   
   
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        //securityManager.setRealm(userRealm);
        //记住我
        securityManager.setRememberMeManager(rememberMeManager);
        //缓存管理器
        securityManager.setCacheManager(redisCacheManager);
        //session管理器
        securityManager.setSessionManager(sessionManager);
        //认证策略(realm之前)
        securityManager.setAuthenticator(modularRealmAuthenticator);
        //securityManager.setAuthenticator(myModularRealmAuthenticator);
        //多realm认证
        securityManager.setRealms(Arrays.asList(userRealm,mobileRealm));
        return securityManager;
    }

4. 配置shiroFilterFactoryBean 其实就是Filter的规则


/**
     * shiro内置请求过滤器
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean (DefaultWebSecurityManager securityManager){
   
   
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        //添加内置过滤器,设置拦截规则
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<>();
        //设置登录请求页面
        shiroFilterFactoryBean.setLoginUrl("/toLogin");
        //设置登出请求页面
        filterChainDefinitionMap.put("/logout","logout");
        //设置未授权页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/unathorized");

        //先对系统资源进行授权访问
        filterChainDefinitionMap.put("/user/add","perms[sys:c:save]");

        //配置路径过滤器，key时ant路径，**表示多级路径，*表示一级路径，？表示一个字符
        //user过滤器表示记住我才能访问（已认证也可以访问）
        filterChainDefinitionMap.put("/index","user");
        filterChainDefinitionMap.put("/user/*","anon");
        filterChainDefinitionMap.put("/**","authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilterFactoryBean;
    }

5. 配置凭证匹配器

  @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher(){
   
   

        //密码加密
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //设置加密算法
        matcher.setHashAlgorithmName("MD5");
        //设置迭代次数 eg: 123--md5->abc--md5->xyz--md5->??? 即设置密码经过多少次MD5加密
        matcher.setHashIterations(3);
        return matcher;
    }

    /**
     * 代表系统资源
     * @return
     */
    @Bean
    public UserRealm userRealm() {
   
   
        UserRealm userRealm = new UserRealm();
        userRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return userRealm;
    }

    /**
     * 代表系统资源
     * @return
     */
    @Bean
    public MobileRealm mobileRealm() {
   
   
        MobileRealm mobileRealm = new MobileRealm();
        mobileRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return mobileRealm;
    }

6. 配置RememberMe

6.1 登陆页面

<div class="layui-container">
    <div class="admin-login-background">
        <div class="layui-form login-form">
            <form class="layui-form" method="post" action="">
                <div class="layui-form-item logo-title">
                    <h1>后台登录</h1>
                </div>
                <div class="layui-form-item">
                    <label class="layui-icon layui-icon-username" ></label>
                    <input type="text" name="username" lay-verify="required" placeholder="用户名" autocomplete="off" class