SpringBoot集成Shiro

阅读数：次 2020-12-24

转载字数统计: 9.5k字 | 预计阅读时长≈ 40分钟

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

概述

简介

Apache Shiro 是一个强大且易用的 Java 安全框架

可以完成身份验证、授权、密码和会话管理

Shiro 不仅可以用在 JavaSE 环境中，也可以用在 JavaEE 环境中

官网： http://shiro.apache.org/

主要功能

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的；

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web 支持，可以非常容易的集成到 Web 环境；

Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

从外部看

应用代码直接交互的对象是 Subject，也就是说 Shiro 的对外 API 核心就是 Subject；

其每个 API 的含义：

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager；可以把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；

SecurityManager：安全管理器；即所有与安全有关的操作都会与 SecurityManager 交互；且它管理着所有 Subject；可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，你可以把它看成 DispatcherServlet 前端控制器；

Realm：域，Shiro 从从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源。

也就是说对于我们而言，最简单的一个 Shiro 应用：

应用代码通过 Subject 来进行认证和授权，而 Subject 又委托给 SecurityManager；
我们需要给 Shiro 的 SecurityManager 注入 Realm，从而让 SecurityManager 能得到合法的用户及其权限进行判断。

从以上也可以看出，Shiro 不提供维护用户/权限，而是通过 Realm 让开发人员自己注入。

三个核心组件：Subject，SecurityManager 和 Realms

Subject：即“当前操作用户”。但是，在 Shiro 中，Subject 这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。

Subject 代表了当前用户的安全操作，SecurityManager 则管理所有用户的安全操作。

SecurityManager：它是 Shiro 框架的核心，典型的 Facade 模式，Shiro 通过 SecurityManager 来管理内部组件实例，并通过它来提供安全管理的各种服务。

Realm： Realm 充当了 Shiro 与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro 会从应用配置的 Realm 中查找用户及其权限信息。

从这个意义上讲，Realm 实质上是一个安全相关的 DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给 Shiro。当配置 Shiro 时，你必须至少指定一个 Realm，用于认证和（或）授权。配置多个 Realm 是可以的，但是至少需要一个。

Shiro 内置了可以连接大量安全数据源（又名目录）的 Realm，如 LDAP、关系数据库（JDBC）、类似 INI 的文本配置资源以及属性文件等。如果缺省的 Realm 不能满足需求，你还可以插入代表自定义数据源的自己的 Realm 实现。

外部架构

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 提高了一些常见的加密组件用于如密码加密/解密的

认证流程

用户 提交 身份信息、凭证信息 封装成 令牌 交由 安全管理器 认证

快速入门

拷贝案例

1、按照官网提示找到 10 分钟快速入门案例：http://shiro.apache.org/10-minute-tutorial.html

GitHub 地址：shiro quickstart
从 GitHub 的文件中可以看出这个快速入门案例是一个 Maven 项目

2、新建一个 Maven 工程，删除其 src 目录，将其作为父工程

3、在父工程中新建一个 Maven 模块

4、复制快速入门案例 pom.xml 文件中的依赖 （版本号自选）

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

    <!-- configure logging -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.29</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.29</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

5、把快速入门案例中的 resource 下的log4j.properties 拷贝到 resources 下

log4j.rootLogger=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n

# General Apache libraries
log4j.logger.org.apache=WARN

# Spring
log4j.logger.org.springframework=WARN

# Default Shiro logging
log4j.logger.org.apache.shiro=INFO

# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

6、拷贝一下 shiro.ini 文件到 resources 下

[users]
# user 'root' with password 'secret' and the 'admin' role
root = secret, admin
# user 'guest' with the password 'guest' and the 'guest' role
guest = guest, guest
# user 'presidentskroob' with password '12345' ("That's the same combination on
# my luggage!!!" ;)), and role 'president'
presidentskroob = 12345, president
# user 'darkhelmet' with password 'ludicrousspeed' and roles 'darklord' and 'schwartz'
darkhelmet = ludicrousspeed, darklord, schwartz
# user 'lonestarr' with password 'vespa' and roles 'goodguy' and 'schwartz'
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# Roles with assigned permissions
#
# Each line conforms to the format defined in the
# org.apache.shiro.realm.text.TextConfigurationRealm#setRoleDefinitions JavaDoc
# -----------------------------------------------------------------------------
[roles]
# 'admin' role has all permissions, indicated by the wildcard '*'
admin = *
# The 'schwartz' role can do anything (*) with any lightsaber:
schwartz = lightsaber:*
# The 'goodguy' role is allowed to 'drive' (action) the winnebago (type) with
# license plate 'eagle5' (instance specific id)
goodguy = winnebago:drive:eagle5

7、复制一下 Quickstart.java 文件

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

;

public class Quickstart {

    private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);


    public static void main(String[] args) {

        // The easiest way to create a Shiro SecurityManager with configured
        // realms, users, roles and permissions is to use the simple INI config.
        // We'll do that by using a factory that can ingest a .ini file and
        // return a SecurityManager instance:

        // Use the shiro.ini file at the root of the classpath
        // (file: and url: prefixes load from files and urls respectively):
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
        securityManager.setRealm(iniRealm);

        // for this simple example quickstart, make the SecurityManager
        // accessible as a JVM singleton.  Most applications wouldn't do this
        // and instead rely on their container configuration or web.xml for
        // webapps.  That is outside the scope of this simple quickstart, so
        // we'll just do the bare minimum so you can continue to get a feel
        // for things.
        SecurityUtils.setSecurityManager(securityManager);

        // Now that a simple Shiro environment is set up, let's see what you can do:

        // get the currently executing user:
        Subject currentUser = SecurityUtils.getSubject();

        // Do some stuff with a Session (no need for a web or EJB container!!!)
        Session session = currentUser.getSession();
        session.setAttribute("someKey", "aValue");
        String value = (String) session.getAttribute("someKey");
        if (value.equals("aValue")) {
            log.info("Retrieved the correct value! [" + value + "]");
        }

        // let's login the current user so we can check against roles and permissions:
        if (!currentUser.isAuthenticated()) {
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
            token.setRememberMe(true);
            try {
                currentUser.login(token);
            } catch (UnknownAccountException uae) {
                log.info("There is no user with username of " + token.getPrincipal());
            } catch (IncorrectCredentialsException ice) {
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
            } catch (LockedAccountException lae) {
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
            }
            // ... catch more exceptions here (maybe custom ones specific to your application?
            catch (AuthenticationException ae) {
                //unexpected condition?  error?
            }
        }

        //say who they are:
        //print their identifying principal (in this case, a username):
        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

        //test a role:
        if (currentUser.hasRole("schwartz")) {
            log.info("May the Schwartz be with you!");
        } else {
            log.info("Hello, mere mortal.");
        }

        //test a typed permission (not instance-level)
        if (currentUser.isPermitted("lightsaber:wield")) {
            log.info("You may use a lightsaber ring.  Use it wisely.");
        } else {
            log.info("Sorry, lightsaber rings are for schwartz masters only.");
        }

        //a (very powerful) Instance Level permission:
        if (currentUser.isPermitted("winnebago:drive:eagle5")) {
            log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
                    "Here are the keys - have fun!");
        } else {
            log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
        }

        //all done - log out!
        currentUser.logout();

        System.exit(0);
    }
}

8、运行 Quickstart.java，得到结果

分析案例

1、通过 SecurityUtils 获取当前执行的用户 Subject

1	Subject currentUser = SecurityUtils.getSubject();

2、通过当前用户拿到 Session

1	Session session = currentUser.getSession();

3、用 Session 存值取值

1 2	session.setAttribute("someKey", "aValue"); String value = (String) session.getAttribute("someKey");

4、判断用户是否被认证

1	currentUser.isAuthenticated()

5、执行登录操作

1	currentUser.login(token);

6、打印其标识主体

1	currentUser.getPrincipal()

7、注销

1	currentUser.logout();

8、总览

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

;

public class Quickstart {

    private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);


    public static void main(String[] args) {

        // 工厂模式，通过 shiro.ini 配置文件中的信息，生成一个工厂实例
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
        securityManager.setRealm(iniRealm);

        // 通过 SecurityUtils 获取当前执行的用户 Subject
        SecurityUtils.setSecurityManager(securityManager);

        // 通过当前用户拿到 Session
        // 使用 shiro 的 Session 做一些事情 （不需要 web 或 EJB 容器）
        Subject currentUser = SecurityUtils.getSubject();

        // 如何用 Session 存值取值
        Session session = currentUser.getSession();
        session.setAttribute("someKey", "aValue");
        String value = (String) session.getAttribute("someKey");
        if (value.equals("aValue")) {
            log.info("Retrieved the correct value! [" + value + "]");
        }

        // 让我们登录当前用户，以便我们可以检查角色和权限
        // 这里和 SpringSecurity 使用了类似的代码，判断用户是否被认证
        if (!currentUser.isAuthenticated()) {
            // 如果被认证，就可以获得一个 令牌（token）
            // 通过用户的账号密码生成一个 令牌
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
            // 设置记住我功能
            token.setRememberMe(true);
            try {
                // 执行登录操作
                currentUser.login(token);
            } catch (UnknownAccountException uae) {
                // 如果用户名不存在
                log.info("There is no user with username of " + token.getPrincipal());
            } catch (IncorrectCredentialsException ice) {
                // 如果密码不正确
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
            } catch (LockedAccountException lae) {
                // 用户被锁定，如密码输出过多，则被锁住
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
            }
            // ... 在此处获得更多异常
            catch (AuthenticationException ae) {
                // 意外情况？ 错误？
            }
        }

        // currentUser 一些用法
        // 打印其标识主体（在这种情况下，为用户名）
        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

        // 测试用户是否有此角色
        if (currentUser.hasRole("schwartz")) {
            log.info("May the Schwartz be with you!");
        } else {
            log.info("Hello, mere mortal.");
        }

        // 细粒度，权限范围小
        // 测试类型化的权限（不是实例级别）
        if (currentUser.isPermitted("lightsaber:wield")) {
            log.info("You may use a lightsaber ring.  Use it wisely.");
        } else {
            log.info("Sorry, lightsaber rings are for schwartz masters only.");
        }

        // x粒度，权限范围广
        // （非常强大的）实例级别权限
        if (currentUser.isPermitted("winnebago:drive:eagle5")) {
            log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
                    "Here are the keys - have fun!");
        } else {
            log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
        }

        // 注销
        currentUser.logout();

        // 退出
        System.exit(0);
    }
}

SpringBoot 集成 Shiro

创建 Shiro 环境

在之前创好的父工程中创建一个普通 SpringBoot 的 Web 工程 springboot-shiro-01，并添加依赖包

<!--shiro以及shiro集成thymeleaf依赖-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>

配置 Shiro

定义 MyRealm 类

package com.itjing.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.realm.Realm;

//  自定义Realm永远完成具体的认证和授权操作
//  Realm父类
//  AuthenticatingRealm 只负责认证（登录）
//  AuthorizingRealm    负责认证（登录）和授权
public class MyRealm implements Realm {

    @Override
    public String getName() {
        return null;
    }

    @Override
    public boolean supports(AuthenticationToken authenticationToken) {
        return false;
    }

    @Override
    public AuthenticationInfo getAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

ctrl+h 查看结构

定义配置类 ShiroConfig

package com.itjing.config;

import com.itjing.realm.MyRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
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;

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

//标记当前类是一个Spring的配置类，用于模拟Spring的配置文件
//在这里我们将要配置Shiro
@Configuration
public class ShiroConfig {
    //配置Shiro的安全管理器
    @Bean
    public SecurityManager securityManager(Realm myRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //设置一个Realm，这个Realm是最终用于完成我们的认证号和授权操作的具体对象
        securityManager.setRealm(myRealm);
        return securityManager;
    }

    //配置一个自定义的Realm的bean，最终将使用这个bean返回的对象来完成我们的认证和授权
    @Bean
    public Realm myRealm() {
        MyRealm realm = new MyRealm();
        return realm;
    }

    //配置一个Shiro的过滤器bean，这个bean将配置Shiro相关的一个规则的拦截
    //例如什么样的请求可以访问什么样的请求不可以访问等等
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        //创建Shiro的拦截的拦截器 ，用于拦截我们的用户请求
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        //设置Shiro的安全管理，设置管理的同时也会指定某个Realm 用来完成我们权限分配
        shiroFilter.setSecurityManager(securityManager);
        //用于设置一个登录的请求地址，这个地址可以是一个html或jsp的访问路径，也可以是一个控制器的路径
        //作用是用于通知Shiro我们可以使用这里路径转向到登录页面，但Shiro判断到我们当前的用户没有登录时就会自动转换到这个路径
        //要求用户完成成功
        shiroFilter.setLoginUrl("/");
        //登录成功后转向页面，由于用户的登录后期需要交给Shiro完成，因此就需要通知Shiro登录成功之后返回到那个位置
        shiroFilter.setSuccessUrl("/success");
        //用于指定没有权限的页面，当用户访问某个功能是如果Shiro判断这个用户没有对应的操作权限，那么Shiro就会将请求
        //转向到这个位置，用于提示用户没有操作权限
        shiroFilter.setUnauthorizedUrl("/noPermission");
        //定义一个Map集合，这个Map集合中存放的数据全部都是规则，用于设置通知Shiro什么样的请求可以访问什么样的请求不可以访问
        Map<String, String> map = new LinkedHashMap<String, String>();
        //  /login 表示某个请求的名字    anon 表示可以使用游客什么进行登录（这个请求不需要登录）
        map.put("/login", "anon");
        //我们可以在这里配置所有的权限规则这列数据真正是需要从数据库中读取出来
        //或者在控制器中添加Shiro的注解
        //  /admin/**  表示一个请求名字的通配， 以admin开头的任意子孙路径下的所有请求
        //  authc 表示这个请求需要进行认证（登录），只有认证（登录）通过才能访问
        // 注意： ** 表示任意子孙路径
        //       *  表示任意的一个路径
        //       ? 表示 任意的一个字符
        map.put("/logout", "logout");//配置登出的请求，登出后会清空当前用户的内存
        map.put("/admin/**", "authc");
        map.put("/user/**", "authc");
        //表示所有的请求路径全部都需要被拦截登录，这个必须必须写在Map集合的最后面,这个选项是可选的
        //如果没有指定 /** 那么如果某个请求不符合上面的拦截规则Shiro将执行这个请求
        //即配置剩余的所有请求全部需要进行登录认证（注意：这个必须写在最后面），可选的配置
        //map.put("/**","authc");
        shiroFilter.setFilterChainDefinitionMap(map);
        return shiroFilter;
    }
}

定义 UserController 测试

package com.itjing.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @RequestMapping("/")
    public String index() {
        return "login";
    }

    @RequestMapping("/login")
    public String login(String username, String password, Model model) {
        return "redirect:/success";
    }

    @RequestMapping("/success")
    public String success() {
        return "success";
    }

    @RequestMapping("/noPermission")
    public String noPermission() {
        return "noPermission";
    }

    @RequestMapping("/user/test")
    public @ResponseBody String userTest() {
        return "这是userTest请求";
    }

    @RequestMapping("/admin/test")
    public @ResponseBody String adminTest() {
        return "这是adminTest请求";
    }

    @RequestMapping("/admin/add")
    public @ResponseBody String adminAdd() {
        Subject subject = SecurityUtils.getSubject();
        return "这是adminAdd请求";
    }
}

定义页面

login.html 、nopermission.html、success.html

login.html

<form action="login" method="post">
  账号<input type="text" name="username" /><br />
  密码<input type="text" name="password" id="password" /><br />
  <input type="submit" value="登录" id="loginBut" />
</form>
<span style="color: red" th:text="${errorMessage}"></span>

nopermission.html

1	<h1>没有权限请联系管理员</h1>

success.html

1	<h1>登录成功</h1>

测试

打开浏览器访问 /success 以及 /admin/test 请求

由于配置/admin/test 的请求需要认证因此无法直接访问而是转向到了登录页面

而访问/success 请求因为没有配置对应的拦截所以可以访问

配置 Shiro 认证账号

修改 MyRealm 类

package com.itjing.realm;

import org.apache.shiro.authc.*;
import org.apache.shiro.realm.AuthenticatingRealm;

//  自定义Realm永远完成具体的认证和授权操作
//  AuthenticatingRealm 只负责认证（登录）的Realm父类
public class MyRealm extends AuthenticatingRealm {
    /**
     * Shiro的认证方法我们需要在这个方法中来获取用户的信息（从数据库中）
     *
     * @param authenticationToken 用户登录时的Token（令牌），这个对象中将存放着我们用户在浏览器中存放的账号和密码
     * @return 返回一个AuthenticationInfo 对象，这个返回以后Shiro会调用这个对象中的一些方法来完成对密码的验证 密码是由Shiro
     * 进行验证是否合法
     * @throws AuthenticationException 如果认证失败Shiro就会抛出AuthenticationException 我们也可以手动自己抛出这个AuthenticationException
     *                                 以及它的任意子异常类不通的异常类型可以认证过程中的不通错误情况我们需要根据异常类型来为用户返回特定的响应数据
     *                                 AuthenticationException 异常的子类  可以我们自己抛出
     *                                 AccountException 账号异常  可以我们自己抛出
     *                                 UnknownAccountException 账号不存在的异常  可以我们自己抛出
     *                                 LockedAccountException  账号异常锁定异常  可以我们自己抛出
     *                                 IncorrectCredentialsException  密码错误异常 这个异常会在Shiro进行密码验证是抛出
     */
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //将AuthenticationToken强转成UsernamePasswordToken 这样获取账号和密码更加的方便
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //获取用户在浏览器中输入的账号
        String username = token.getUsername();
        //认证账号,正常情况我们需要这里从数据库中获取账号的信息，以及其他关键数据，例如账号是否被冻结等等
        String dbusername = username;
        if (!"admin".equals(dbusername) && !"zhangsan".equals(dbusername)) {//判断用户账号是否正确
            throw new UnknownAccountException("账号错误");
        }
        if ("zhangsan".equals(username)) {
            throw new LockedAccountException("账号被锁定");
        }
        //定义一个密码这个密码应该来自数据库中
        String dbpassword = "123456";
        //认证密码是否正确
        return new SimpleAuthenticationInfo(dbusername, dbpassword, getName());
    }
}

修改 UserController

@RequestMapping("/login")
public String login(String username, String password, Model model) {
    //创建一个shiro的Subject对象，利用这个对象来完成用户的登录认证
    Subject subject = SecurityUtils.getSubject();
    //判断当前用户是否已经认证过，如果已经认证过着不需要认证如果没有认证过则进入if完成认证
    if (!subject.isAuthenticated()) {
        //创建一个用户账号和密码的Token对象，并设置用户输入的账号和面
        //这个对象将在Shiro中被获取
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        try {
            //例如账号不存在或密码错误等等，我们需要根据不同的异常类型来判断用户的登录状态并给与友好的信息提示
            //调用login后Shiro就会自动执行我们自定义的Realm中的认证方法
            subject.login(token);
        } catch (UnknownAccountException e) {
            //进入catch 表示用户的账号错误，这个异常是我们在后台抛出的
            System.out.println("---------------账号不存在");
            model.addAttribute("errorMessage", "账号不存在");
            return "login";
        } catch (LockedAccountException e) {
            //进入catch 表示用户的账号被锁定，这个异常是我们在后台抛出的
            System.out.println("===============账号被锁定");
            model.addAttribute("errorMessage", "账号被冻结");
            return "login";
        } catch (IncorrectCredentialsException e) {
            //进入catch 表示用户的密码，这个异常是shiro在认证密码时抛出
            System.out.println("***************密码不匹配");
            model.addAttribute("errorMessage", "密码错误");
            return "login";
        }
    }
    return "redirect:/success";
}

测试

打开浏览器访问，当输入账号为 shangsan 密码任意，则会显示账号冻结的错误提示

输入账号 abc 密码任意，则出现账号不存在的提示

输入账号 admin 密码为 123，则出现密码错误的提示

当输入账号为 admin 密码为 123456，则户登录成功显示登录成功

认证缓存

当登录成功过一次以后我可以点击后退，然后输入任意账号和密码这时无论输入什么信息 Shiro 都会认为认证成功，这是因为 Shiro 在登录成功以后会将数据写入 Shiro 的缓存导致，因此应该在登录请求的控制器中在判断是否认证过之前添加一个登出操作，已清空缓存这样就可以重复测试登录。

修改 UserController

@RequestMapping("/login")
    public String login(String username, String password, Model model) {
        //创建一个shiro的Subject对象，利用这个对象来完成用户的登录认证
        Subject subject = SecurityUtils.getSubject();
        //登出方法调用，用于清空登录时的缓存信息，否则无法重复登录
        //在验证之前先登出
        subject.logout();
        ...
        ...
    }

密码加密

修改 MyRealm 类

//定义一个密码，这个密码是数据库中的密码我们应该从数据库中获取
String dbpassword="123456";
//密码加密码
//参数 1 为加密算法 我们选择MD5加密
//参数 2 为被加密的数据的数据
//参数 3 为加密时的盐值 ，用于改变加密后数据结果
//      通常这个盐值需要选择一个表中唯一的数据例如表中的账号
//参数 4 为需要对数据使用指定的算法加密多少次
Object obj=new SimpleHash("MD5",dbpassword,"",1);
//认证密码是否正确 使用加密后的密码登录
return new SimpleAuthenticationInfo(dbusername,obj.toString(),getName());

注意：

1、通常数据库中存放的数据不应该是明码 123456，而是加密后的数据，例如 e10adc3949ba59abbe56e057f20f883e，这是使用 MD5 加密后的 123456，如果数据库中的密码已经是加密后的那么这里可以不选择进行加密。

2、如果数据库中的密码已经加密那么页面中传递数据前必须要对密码进行加密才能传递，否则无法可能会登录失败。

3、如果选择加密传递那么页面和数据库中的密码加密次数以及盐必须相同，否则登录一定失败。

加入 jquery 和 md5 的 js

<form action="login" method="post">
  账号<input type="text" name="username" /><br />
  密码<input type="text" id="password" /><br />
  <input type="hidden" name="password" id="md5Password" />
  <input type="submit" value="登录" id="loginBut" />
</form>
<span style="color: red" th:text="${errorMessage}"></span>
<script th:src="@{/js/jquery1.9.0.min.js}"></script>
<script th:src="@{/js/jQuery.md5.js}"></script>
<script>
  $(function () {
    $('#loginBut').bind('click', function () {
      var v_password = $('#password').val()
      $('#md5Password').val($.md5(v_password))
    })
  })
</script>

权限分配

需要判断用户哪个权限是否可以使用，我们就必须要先为用户分配一个权限才可以分配需要在 MyRealm 类中配置并且修改继承的父类

修改 MyRealm 类

修改 MyRealm 类继承的父类为 AuthorizingRealm 类，并实现抽象方法 doGetAuthorizationInfo()

//Shiro用户授权的回调方法
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    //从Shiro中获取用户名
    Object username = principalCollection.getPrimaryPrincipal();
    //创建一个SimpleAuthorizationInfo类的对象，利用这个对象需要设置当前用户的权限信息
    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
    //创建角色信息的集合
    Set<String> roles = new HashSet<String>();
    //这里应该根据账号到数据库中获取用户的所对应的所有角色信息并初始化到roles集合中
    if ("admin".equals(username)) {
        roles.add("admin");
        roles.add("user");
    } else if ("zhangsan".equals(username)) {
        roles.add("user");
    }
    Set<String> psermission = new HashSet<String>();
    if ("admin".equals(username)) {
        psermission.add("admin:add");
    }
    //设置角色信息
    simpleAuthorizationInfo.setRoles(roles);
    simpleAuthorizationInfo.setStringPermissions(psermission);
    return simpleAuthorizationInfo;
}

修改 ShiroConfig

用户拥有角色和权限以后需要配置 Shiro 的权限规则，注释掉之前 zhangsan 设定的 “账号被锁定”

//配置一个Shiro的过滤器bean，这个bean将配置Shiro相关的一个规则的拦截
//例如什么样的请求可以访问什么样的请求不可以访问等等
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
    //创建Shiro的拦截的拦截器 ，用于拦截我们的用户请求
    ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
    //设置Shiro的安全管理，设置管理的同时也会指定某个Realm 用来完成我们权限分配
    shiroFilter.setSecurityManager(securityManager);
    //用于设置一个登录的请求地址，这个地址可以是一个html或jsp的访问路径，也可以是一个控制器的路径
    //作用是用于通知Shiro我们可以使用这里路径转向到登录页面，但Shiro判断到我们当前的用户没有登录时就会自动转换到这个路径
    //要求用户完成成功
    shiroFilter.setLoginUrl("/");
    //登录成功后转向页面，由于用户的登录后期需要交给Shiro完成，因此就需要通知Shiro登录成功之后返回到那个位置
    shiroFilter.setSuccessUrl("/success");
    //用于指定没有权限的页面，当用户访问某个功能是如果Shiro判断这个用户没有对应的操作权限，那么Shiro就会将请求
    //转向到这个位置，用于提示用户没有操作权限
    shiroFilter.setUnauthorizedUrl("/noPermission");
    //定义一个Map集合，这个Map集合中存放的数据全部都是规则，用于设置通知Shiro什么样的请求可以访问什么样的请求不可以访问
    Map<String, String> map = new LinkedHashMap<String, String>();
    //  /login 表示某个请求的名字    anon 表示可以使用游客什么进行登录（这个请求不需要登录）
    map.put("/login", "anon");


    //roles[admin] 表示 以/admin/**开头的请求需要拥有admin角色才可以访问否   则返回没有权限的页面
    //perms[admin:add] 表示 /admin/test的请求需要拥有 admin:add权限才可访问
    //注意：admin:add仅仅是一个普通的字符串用于标记某个权限功能
    map.put("/admin/test","authc,perms[admin:add]");
    map.put("/admin/**","authc,roles[admin]");
    map.put("/user/**","authc,roles[user]");



    //表示所有的请求路径全部都需要被拦截登录，这个必须必须写在Map集合的最后面,这个选项是可选的
    //如果没有指定 /** 那么如果某个请求不符合上面的拦截规则Shiro将执行这个请求
    //即配置剩余的所有请求全部需要进行登录认证（注意：这个必须写在最后面），可选的配置
    //map.put("/**","authc");
    shiroFilter.setFilterChainDefinitionMap(map);
    return shiroFilter;
}

测试

基于注解的权限控制

Shiro 不仅支持配置的权限控制还支持基于控制器注解的权限控制，如果需要使用 Shiro 的注解权限必须要在配置类中启动 Shiro 注解支持

修改 ShiroConfig

@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
    //创建Shiro的拦截的拦截器 ，用于拦截我们的用户请求
    ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
    //设置Shiro的安全管理，设置管理的同时也会指定某个Realm 用来完成我们权限分配
    shiroFilter.setSecurityManager(securityManager);
    //用于设置一个登录的请求地址，这个地址可以是一个html或jsp的访问路径，也可以是一个控制器的路径
    //作用是用于通知Shiro我们可以使用这里路径转向到登录页面，但Shiro判断到我们当前的用户没有登录时就会自动转换到这个路径
    //要求用户完成成功
    shiroFilter.setLoginUrl("/");
    //登录成功后转向页面，由于用户的登录后期需要交给Shiro完成，因此就需要通知Shiro登录成功之后返回到那个位置
    shiroFilter.setSuccessUrl("/success");
    //用于指定没有权限的页面，当用户访问某个功能是如果Shiro判断这个用户没有对应的操作权限，那么Shiro就会将请求
    //转向到这个位置，用于提示用户没有操作权限
    shiroFilter.setUnauthorizedUrl("/noPermission");
    //定义一个Map集合，这个Map集合中存放的数据全部都是规则，用于设置通知Shiro什么样的请求可以访问什么样的请求不可以访问
    Map<String, String> map = new LinkedHashMap<String, String>();
    //  /login 表示某个请求的名字    anon 表示可以使用游客什么进行登录（这个请求不需要登录）
    map.put("/login", "anon");


    //表示所有的请求路径全部都需要被拦截登录，这个必须必须写在Map集合的最后面,这个选项是可选的
    //如果没有指定 /** 那么如果某个请求不符合上面的拦截规则Shiro将执行这个请求
    //即配置剩余的所有请求全部需要进行登录认证（注意：这个必须写在最后面），可选的配置
    //map.put("/**","authc");
    shiroFilter.setFilterChainDefinitionMap(map);
    return shiroFilter;
}

	/**
     * 开启Shiro的注解例如（  @RequiresRoles @RequiresUser @RequiresPermissions）
     * 需要借助SpringAOP来扫描这些注解
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator=new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    /**
     * 开启AOP的注解支持
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor=new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

注意：启动注解的权限控制以后需要删除在 Shiro 配置类中的权限拦截的配置规则

1
2
3

map.put("/admin/test","authc,perms[admin:add]");
map.put("/admin/**","authc,roles[admin]");
map.put("/user/**","authc,roles[user]");

修改 UserController

@RequiresRoles(value = {"user"})
@RequestMapping("/user/test")
public @ResponseBody String userTest(){
    return "这个userTest请求";
}

//RequiresRoles  Shiro的注解 表示访问这功能必须要拥有 admin角色
//注意如果需要支持多个角色就直接填写多个角色名称即可 例如 "admin","user"
//RequiresRoles 属性 logical 用于在拥有多个角色时使用 取值为Logical.AND 表示并且的意思必须同时拥有多个角色 或
//               Logical.OR 或者的意思，只要拥有多个角色中的其中一个即可
//注意使用了注解以后需要配置Spring声明式异常捕获，否则将在浏览器中直接看到Shiro的错误信息而不是友好的信息提示
@RequiresRoles(value = {"admin"})
@RequestMapping("/admin/test")
public @ResponseBody String adminTest(){
    return "这个adminTest请求";
}

//@RequiresPermissions 注解用于指定当前请求必须要拥有指定的权限名字为 admin:add才能访问
//admin:add 只是一个普通的权限名称字符串，表示admin下的add功能
@RequiresPermissions(value = {"admin:add"})
@RequestMapping("/admin/add")
public @ResponseBody String adminAdd(){
    Subject subject= SecurityUtils.getSubject();
    // 验证当前用户是否拥有这个权限
	// subject.checkPermission();
	// 验证当前用户是否拥有这个角色
	// subject.checkRole();
    return "这个adminAdd请求";
}

//配置一个Spring的异常监控，当工程抛出了value所指定的所以异常类型以后将直接进入到当前方法中
@ExceptionHandler(value = {Exception.class})
public String myError(Throwable throwable){
    //获取异常的类型，应该根据不同的异常类型进入到不通的页面显示不同提示信息
    System.out.println(throwable.getClass());
    System.out.println("---------------------------------");
    return "noPermission";
}

注意：Shiro 验证失败以后会抛出异常，因此这时必须要配置一个 Spring 的异常监控方法 myError 否则当前 Shiro 权限认证失败以后将无法转向到错误页面。

Shiro 标签

使用 Thymeleaf 整合 Shiro 标签

添加 Maven 依赖

<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>

添加配置 Bean

@Bean
public ShiroDialect shiroDialect() {
    return new ShiroDialect();
}

页面引入命名空间

1	xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"

Shiro 标签语法

作为属性控制

1	<button type="button" shiro:authenticated="true">权限控制</button>

作为标签

1
2
3

<shiro:hasRole name="admin">
  <button type="button">权限控制</button>
</shiro:hasRole>

常用标签说明

guest 标签

1	<shiro:guest> </shiro:guest>

用户没有身份验证时显示相应信息，即游客访问信息。

user 标签

1	<shiro:user>　　 </shiro:user>

用户已经身份验证/记住我登录后显示相应的信息。

authenticated 标签

1	<shiro:authenticated>　　 </shiro:authenticated>

用户已经身份验证通过，即 Subject.login 登录成功，不是”记住我”登录的

notAuthenticated 标签

1	<shiro:notAuthenticated> </shiro:notAuthenticated>

用户已经身份验证通过，即没有调用 Subject.login 进行登录，包括”记住我”自动登录的也属于未进行身份验证。

principal 标签

1	<shiro:principal property="username"> </shiro:principal>

相当于 ((User)Subject.getPrincipals()).getUsername() 。

lacksPermission 标签

1	<shiro:lacksPermission name="org:create"> </shiro:lacksPermission>

如果当前 Subject 没有权限将显示 body 体内容。

hasRole 标签

1	<shiro:hasRole name="admin">　　 </shiro:hasRole>

如果当前 Subject 有角色将显示 body 体内容。

hasAnyRoles 标签

1	<shiro:hasAnyRoles name="admin,user"> </shiro:hasAnyRoles>

如果当前 Subject 有任意一个角色（或的关系）将显示 body 体内容。

lacksRole 标签

1	<shiro:lacksRole name="abc">　　 </shiro:lacksRole>

如果当前 Subject 没有角色将显示 body 体内容。

hasPermission 标签

<!--如果当前Subject有权限将显示body体内容。-->
<shiro:hasPermission name="user:create">　　
</shiro:hasPermission>

<!--如果当前Subject有任意一个权限（或的关系）将显示body体内容。-->
<shiro:hasAnyPermissions name="admin:add,admin:update">
</shiro:hasAnyPermissions>
<!--必须拥有指定的全部角色。-->
<shiro:hasAllRoles name=""></shiro:hasAllRoles>
<!--必须拥有指定的全部权限。-->
<shiro:hasAllPermissions name=""></shiro:hasAllRoles>

后续更新 shiro 更多用法！

本文作者： LiJing
发布时间： 2020-12-24
最后更新： 2024-06-24
本文标题： SpringBoot集成Shiro
本文链接： https://blog-yilia.xiaojingge.com/posts/8c925ea2.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！

概述

简介

主要功能

从外部看

外部架构

认证流程

快速入门

拷贝案例

分析案例

SpringBoot 集成 Shiro

创建 Shiro 环境

配置 Shiro

定义 MyRealm 类

定义配置类 ShiroConfig

定义 UserController 测试

定义页面

测试

配置 Shiro 认证账号

修改 MyRealm 类

修改 UserController

测试

认证缓存

修改 UserController

密码加密

修改 MyRealm 类

修改 login.html

权限分配

修改 MyRealm 类

修改 ShiroConfig

测试

基于注解的权限控制

修改 ShiroConfig

修改 UserController

Shiro 标签

使用 Thymeleaf 整合 Shiro 标签

Shiro 标签语法

常用标签说明

guest 标签

user 标签

authenticated 标签

notAuthenticated 标签

principal 标签

lacksPermission 标签

hasRole 标签

hasAnyRoles 标签

lacksRole 标签

hasPermission 标签