Shiro1.9学习笔记

一、Shiro概述

1、Shiro简介

1.1 介绍

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

Apache Shiro 是一个功能强大且易于使用的 Java 安全(权限)框架。Shiro 可以完成：认证、授权、加密、会话管理、与 Web 集成、缓存 等。借助 Shiro 您可以快速轻松地保护任何应用程序——从最小的移动应用程序到最大的 Web 和企业应用程序。

1.2 Shiro特点

• 易于使用：使用 Shiro 构建系统安全框架非常简单。就算第一次接触也可以快速掌握
• 全面：Shiro 包含系统安全框架需要的功能，满足安全需求的“一站式服务”
• 灵活：Shiro 可以在任何应用程序环境中工作。虽然它可以在 Web、EJB 和 IoC 环境中工作，但不需要依赖它们。Shiro 也没有强制要求任何规范，甚至没有很多依赖项
• 强力支持 Web：Shiro 具有出色的 Web 应用程序支持，可以基于应用程序 URL 和 Web 协议（例如 REST）创建灵活的安全策略，同时还提供一组 JSP 库来控制页面输出
• 兼容性强：Shiro 的设计模式使其易于与其他框架和应用程序集成。Shiro 与 Spring、Grails、Wicket、Tapestry、Mule、Apache Camel、Vaadin 等框架无缝集成
• 社区支持：Shiro 是 Apache 软件基金会的一个开源项目，有完备的社区支持，文档支持。如果需要，像 Katasoft 这样的商业公司也会提供专业的支持和服务

2、Shiro与SpringSecurity的对比

SpringSecurity参考：Spring Security学习笔记

• Spring Security 基于 Spring 开发，项目若使用 Spring 作为基础，配合 Spring Security 做权限更加方便，而 Shiro 需要和 Spring 进行整合开发；
• Spring Security 功能比 Shiro 更加丰富些，例如安全维护方面；
• Spring Security 社区资源相对比 Shiro 更加丰富；
• Shiro 的配置和使用比较简单，Spring Security 上手复杂些；
• Shiro 依赖性低，不需要任何框架和容器，可以独立运行。Spring Security 依赖 Spring 容器；
• shiro 不仅仅可以使用在 web 中，它可以工作在任何应用环境中。在集群会话时 Shiro 最重要的一个好处或许就是它的会话是独立于容器的

3、Shiro基本功能

• Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
• Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用 户是否能进行什么操作，如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户 对某个资源是否具有某个权限；
• Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境，也可以是 Web 环境的；
• Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
• Web Support：Web 支持，可以非常容易的集成到 Web 环境；
• Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
• Concurrency：Shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
• Testing：提供测试支持；
• Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
• Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

4、Shiro原理

4.1 Shiro 架构(外部)

从外部来看 Shiro ，即从应用程序角度的来观察如何使用Shiro 完成工作

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

4.2 shiro架构(内部)

• Subject：任何可以与应用交互的“用户”；
• SecurityManager ：相当于 SpringMVC 中的 DispatcherServlet；是 Shiro 的心脏； 所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进 行认证、授权、会话及缓存的管理。
• Authenticator：负责 Subject 认证，是一个扩展点，可以自定义实现；可以使用认证策略（Authentication Strategy），即什么情况下算用户认证通过了；
• Authorizer：授权器、即访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
• Realm：可以有 1 个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是 JDBC 实现，也可以是内存实现等等；由用户提供；所以一般在应用中都需要实现自己的 Realm；
• SessionManager：管理 Session 生命周期的组件；而 Shiro 并不仅仅可以用在 Web环境，也可以用在如普通的 JavaSE 环境
• CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据 基本上很少改变，放到缓存中后可以提高访问的性能
• Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密/解密。

二、Shiro基本使用

1、环境准备

引入shiro依赖

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.9.0version>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.2version>
dependency>

创建ini文件，因为Shiro获取权限相关信息可以通过数据库获取，也可以通过ini配置文件获取，后期放数据库

[users]
shawn=123456
leo=123456

2、登录认证

2.1 登录认证概念

• 身份验证：一般需要提供如身份ID等一些标识信息来表明登录者的身份，如提供email，用户名/密码来证明
• 在shiro中，用户需要提供**principals（身份）**和credentials（证明）给shiro，从而应用能验证用户身份
• principals：身份，即主体的标识属性，可以是任何属性，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/邮箱/手机号
• credentials：证明/凭证，即只有主体知道的安全值，如密码/数字证书等。
• 最常见的principals和credentials组合就是用户名/密码

2.2 登录认证基本流程

• 收集用户身份/凭证，即如用户名/密码
• 调用 Subject.login 进行登录，如果失败将得到相应 的 AuthenticationException异常，根据异常提示用户错误信息；否则登录成功
• 创建自定义的 Realm类，继承 org.apache.shiro.realm.AuthenticatingRealm类,实现 doGetAuthenticationInfo() 方法

2.3 登录认证实例

• 初始化获取SecurityManager
• 获取subject对象
• 创建token对象，web应用用户名密码从页面传递
• 完成登录

 public static void main(String[] args) {
        //1初始化获取SecurityManager
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //2获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        //3创建token对象，web应用用户名密码从页面传递
        AuthenticationToken token = new UsernamePasswordToken("shawn","123456");
        //4完成登录
        try {
            subject.login(token);
            System.out.println("登录成功");
        }
        catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        }
        catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        }
        catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }

2.4 身份认证源码流程

• 首先调用 Subject.login(token) 进行登录，其会自动委托给 SecurityManager
• SecurityManager负责真正的身份验证逻辑；它会委托给 Authenticator进行身份验证
• Authenticator 才是真正的身份验证者，Shiro API 中核心的身份 认证入口点，此处可以自定义插入自己的实现；
• Authenticator 可能会委托给相应的 AuthenticationStrategy 进 行多 Realm 身份验证，默认 ModularRealmAuthenticator会调用 AuthenticationStrategy进行多 Realm 身份验证；
• Authenticator 会把相应的 token 传入 Realm，从 Realm 获取 身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。

3、角色与授权

3.1 授权概念

• 授权，也叫访问控制，即在应用中控制谁访问哪些资源（如访问页面/编辑数据/页面 操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限 （Permission）、角色（Role）
• 主体(Subject)：访问应用的用户，在 Shiro 中使用 Subject 代表该用户。用户只有授权 后才允许访问相应的资源
• 资源(Resource)：在应用中用户可以访问的 URL，比如访问 JSP 页面、查看/编辑 某些 数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问
• 权限(Permission)：安全策略中的原子授权单位，通过权限我们可以表示在应用中用户 有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：访问用 户列表页面查看/新增/修改/删除用户数据（即很多时候都是CRUD（增查改删）式权限控 制）等。权限代表了用户有没有操作某个资源的权利，即反映在某个资源上的操作允不允 许。
• Shiro 支持粗粒度权限（如用户模块的所有权限）和细粒度权限（操作某个用户的权限， 即实例级别的）
• 角色(Role)：权限的集合，一般情况下会赋予用户角色而不是权限，即这样用户可以拥有 一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等 都是角色，不同的角色拥有一组不同的权限

3.2 授权方式

//编程式
subject.hasRole("admin")
//注解式
@RequiresRoles("admin")
// JSP/GSP 标签
<shiro:hasRole name="admin">
</shiro:hasRole>

3.3 授权流程

• 首先调用Subject.isPermitted的/hasRole接口，其会委托给SecurityManager，而SecurityManager接着会委托给 Authorizer；
• Authorizer是真正的授权者，如果调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；
• 在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；
• Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted/hasRole 会返回 true，否则返回false表示授权失败

3.4 代码实例

首先修改resource下的shiro.ini文件

[users]
zhangsan=7174f64b13022acd3c56e2781e098a5f
shawn=123456,role1,role2

[roles]
role1=user:insert,user:select

修改主函数进行测试

public static void main(String[] args) {
    //1初始化获取SecurityManager
    DefaultSecurityManager securityManager=new DefaultSecurityManager();
    IniRealm iniRealm=new IniRealm("classpath:shiro.ini");
    securityManager.setRealm(iniRealm);

    // 其中 shiro.ini 在 resources 的根目录下，此方法已经过期
    // Factory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    // SecurityManager securityManager = factory.getInstance();
    SecurityUtils.setSecurityManager(securityManager);
    //2获取Subject对象
    Subject subject = SecurityUtils.getSubject();
    //3创建token对象，web应用用户名密码从页面传递
    AuthenticationToken token = new UsernamePasswordToken("shawn","123456");
    //4完成登录
    try {
        subject.login(token);
        System.out.println("登录成功");
        //5判断角色
        boolean hasRole = subject.hasRole("role1");
        System.out.println("是否拥有此角色 = " + hasRole);
        //6判断权限
        boolean permitted = subject.isPermitted("user:insert1111");
        System.out.println("是否拥有此权限 = " + permitted);
        //也可以用checkPermission方法，但没有返回值，没权限抛AuthenticationException
        subject.checkPermission("user:select1111");
    }
    catch (UnknownAccountException e) {
        e.printStackTrace();
        System.out.println("用户不存在");
    }
    catch (IncorrectCredentialsException e) {
        e.printStackTrace();
        System.out.println("密码错误");
    }
    catch (AuthenticationException e) {
        e.printStackTrace();

    }
}

4、Shiro加密

实际系统开发中，一些敏感信息需要进行加密，比如说用户的密码。Shiro 内嵌很多 常用的加密算法，比如 MD5 加密。Shiro 可以很简单的使用信息加密。

public static void main(String[] args) {
    //密码明文
    String password = "shawn";
    //使用md5加密
    Md5Hash md5Hash = new Md5Hash(password);
    System.out.println("md5加密 = " + md5Hash.toHex());
    //带盐的md5加密，盐就是在密码明文后拼接新字符串，然后再进行加密
    Md5Hash md5Hash2 = new Md5Hash(password,"salt");
    System.out.println("带盐的md5加密 = " + md5Hash2.toHex());
    //为了保证安全，避免被破解还可以多次迭代加密，保证数据安全
    Md5Hash md5Hash3 = new Md5Hash(password,"salt",3);
    System.out.println("md5带盐的3次加密 = " + md5Hash3.toHex());
    //使用父类进行加密
    SimpleHash simpleHash = new SimpleHash(
            "MD5",password,"salt",3);
    System.out.println("父类带盐的3次加密 = " + simpleHash.toHex());

}

5、自定义登陆认证

Shiro 默认的登录认证是不带加密的，如果想要实现加密认证需要自定义登录认证， 自定义 Realm；首先是创建自定义Realm

public class MyRealm extends AuthenticatingRealm {
    //自定义登录认证方法，shiro的login方法底层会调用该类的认证方法进行认证
    //需要配置自定义的realm生效，在ini文件中配置，在Springboot中配置
    //该方法只是获取进行对比的信息，认证逻辑还是按照shiro底层认证逻辑完成
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1获取身份信息
        String principal = authenticationToken.getPrincipal().toString();
        //2获取凭证信息
        String password = new String((char[])authenticationToken.getCredentials());
        System.out.println("认证用户信息："+principal+"---"+password);

        //3获取数据库中存储的用户信息
        if(principal.equals("shawn")){
            //3.1数据库中存储的加盐3次迭代的密码
            // 第二种方法密码，需要自己进行加密
//            String pwdInfo = "123456 ";
            // 第一种方法
            String pwdInfo = "d1b129656359e35e95ebd56a63d7b9e0";
            //4创建封装校验逻辑对象，封装数据返回
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    pwdInfo,
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }

        return null;
    }
}

第一种方法

public static void main(String[] args) {
    //1初始化获取SecurityManager
    Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    SecurityManager securityManager = factory.getInstance();
    SecurityUtils.setSecurityManager(securityManager);
    //2获取Subject对象
    Subject subject = SecurityUtils.getSubject();
    //3创建token对象，web应用用户名密码从页面传递
    AuthenticationToken token = new UsernamePasswordToken("shawn","123456");
    //4完成登录
    try {
        subject.login(token);
        System.out.println("登录成功");
        //5判断角色
        boolean hasRole = subject.hasRole("role1");
        System.out.println("是否拥有此角色 = " + hasRole);
        //6判断权限
        boolean permitted = subject.isPermitted("user:insert1111");
        System.out.println("是否拥有此权限 = " + permitted);
        //也可以用checkPermission方法，但没有返回值，没权限抛AuthenticationException
        subject.checkPermission("user:select1111");
    }
    catch (UnknownAccountException e) {
        e.printStackTrace();
        System.out.println("用户不存在");

    }
    catch (IncorrectCredentialsException e) {
        e.printStackTrace();
        System.out.println("密码错误");
    }
    catch (AuthenticationException e) {
        e.printStackTrace();
    }
}

同时在Ini文件添加

[main]
md5CredentialsMatcher=org.apache.shiro.authc.credential.Md5CredentialsMatcher
md5CredentialsMatcher.hashIterations=3

myrealm=com.atguigu.shirotest.MyRealm
myrealm.credentialsMatcher=$md5CredentialsMatcher
securityManager.realms=$myrealm

第二种方法，新的方法

public static void main(String[] args) {
    //1初始化获取SecurityManager
    DefaultSecurityManager securityManager=new DefaultSecurityManager(new MyRealm());
    SecurityUtils.setSecurityManager(securityManager);
    //2获取Subject对象
    Subject subject = SecurityUtils.getSubject();
    //3创建token对象，web应用用户名密码从页面传递
    AuthenticationToken token = new UsernamePasswordToken("shawn","123456");
    //4完成登录
    try {
        subject.login(token);
        System.out.println("登录成功");
        //5判断角色
        boolean hasRole = subject.hasRole("role1");
        System.out.println("是否拥有此角色 = " + hasRole);
        //6判断权限
        boolean permitted = subject.isPermitted("user:insert1111");
        System.out.println("是否拥有此权限 = " + permitted);
        //也可以用checkPermission方法，但没有返回值，没权限抛AuthenticationException
        subject.checkPermission("user:select1111");
    }
    catch (UnknownAccountException e) {
        e.printStackTrace();
        System.out.println("用户不存在");
    }
    catch (IncorrectCredentialsException e) {
        e.printStackTrace();
        System.out.println("密码错误");
    }
    catch (AuthenticationException e) {
        e.printStackTrace();
    }
}

三、Shiro整合Springboot

1、登录认证准备

1.1 环境准备

首先创建SpringBoot脚手架项目，导入依赖

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-spring-boot-web-starterartifactId>
    <version>1.9.0version>
dependency>


<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.5.2version>
dependency>


<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.30version>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
dependency>

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-thymeleafartifactId>
dependency>

<dependency>
    <groupId>com.github.theborakompanionigroupId>
    <artifactId>thymeleaf-extras-shiroartifactId>
    <version>2.0.0version>
dependency>


<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-ehcacheartifactId>
    <version>1.10.0version>
dependency>
<dependency>
    <groupId>commons-iogroupId>
    <artifactId>commons-ioartifactId>
    <version>2.11.0version>
dependency>

Mysql脚本，配置好mysql

CREATE DATABASE IF NOT EXISTS `shirodb` CHARACTER SET utf8mb4;
USE `shirodb`;
CREATE TABLE `user` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` VARCHAR(30) DEFAULT NULL COMMENT '用户名',
  `pwd` VARCHAR(50) DEFAULT NULL COMMENT '密码',
  `rid` BIGINT(20) DEFAULT NULL COMMENT '角色编号',
PRIMARY KEY(`id`) 
) ENGINE = INNODB AUTO_INCREMENT = 2 DEFAULT CHARSET = utf8 COMMENT = '用户表';

配置application.yaml文件

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/*.xml
spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shirodb?characterEncoding=utf-8&useSSL=false
    username: root
    password: root
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
# 未认证的请求重定向地址
shiro:
  loginUrl: /myController/login

1.2 后端整合

创建各个模块和类

// 实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
    private Integer rid;
}


// Mapper层
@Mapper
public interface UserMapper extends BaseMapper<User> {

}


// Service层，接口类自己定义(方法抽取一下即可)
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;
    
    
    @Override
    public User getUserInfoByName(String name) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name",name);
        User user = userMapper.selectOne(wrapper);
        return user;
    }
}

// controller层
@Controller
@RequestMapping("myController")
public class MyController {

    /**
     * 登录
     * @param username 用户名
     * @param password 密码
     * @return {@link String}
     */
    @GetMapping("userLogin")
    @ResponseBody
    public String login(@RequestParam("username") String username, @RequestParam("password") String password){
        
        // 默认30分钟过期
        //永不过期,在登陆最开始加上
        //SecurityUtils.getSubject().getSession().setTimeout(-1000L);
        //其他时间 单位毫秒
        //SecurityUtils.getSubject().getSession().setTimeout(1800000);
        
        
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
        try{
            subject.login(usernamePasswordToken);
            return "success";
        }catch (Exception e) {
            e.printStackTrace();
            return "error";
        }
    }
}

创建自定义realm

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;
    /**
     * 自定义授权
     *
     * @param principals 权限
     * @return {@link AuthorizationInfo}
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }


    /**
     * 自定义身份验证
     *
     * @param token 令牌
     * @return {@link AuthenticationInfo}
     * @throws AuthenticationException 身份验证异常
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //1. 获取用户身份信息
        String name = token.getPrincipal().toString();
        //2. 调用业务层获取用户信息
        User user = userService.getUserInfoByName(name);
        //3. 非空判断,将数据封装返回
        if (user != null) {
            return new SimpleAuthenticationInfo(
                    token.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    name
            );
        }
        return null;
    }
}

创建配置类

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2创建加密对象，设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4将myRealm存入defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealm(myRealm);
        //5返回
        return defaultWebSecurityManager;
    }

    //配置Shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/myController/login","anon");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        return  definition;
    }
}

1.3 前端thymeleaf整合

引入thymeleaf依赖后，在resource/templares创建login.html和main.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>Shiro 登录认证h1>
<br>
<form action="/myController/userLogin">
    <div>用户名：<input type="text" name="username" value="">div>
    <div>密码：<input type="password" name="password" value="">div>
    <div><input type="submit" value="登录">div>
form>
body>
html>



DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>
    <br>
    Shiro 登录认证后主页面h1>
    登录用户为： <span th:text="${session.user}">span>
body>

改造controller，让其返回走视图处理器，去除@ResponseBody

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("login")
    public String login(){
        return "login";
    }

    @GetMapping("userLogin")
    public String login(@RequestParam("username") String username, @RequestParam("password") String password,HttpSession session){
        //1 获取  Subject 对象
        Subject subject = SecurityUtils.getSubject();
        //2 封装请求数据到 token 对象中
        AuthenticationToken token = new UsernamePasswordToken(username,password);
        //3 调用  login 方法进行登录认证
        try {
            subject.login(token);
            session.setAttribute("user",token.getPrincipal().toString());
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败");
            return "登录失败";
        }
    }

}

2、多 realm 认证策略

2.1 实现原理

当应用程序配置多个 Realm 时，例如：用户名密码校验、手机号验证码校验等等。 Shiro 的 ModularRealmAuthenticator 会使用内部的AuthenticationStrategy 组件判断认证是成功还是失败。

AuthenticationStrategy 是一个无状态的组件，它在身份验证尝试中被询问 4 次（这 4 次交互所需的任何必要的状态将被作为方法参数）：

• 在所有 Realm 被调用之前
• 在调用 Realm 的 getAuthenticationInfo 方法之前
• 在调用 Realm 的 getAuthenticationInfo 方法之后
• 在所有 Realm 被调用之后

认证策略的另外一项工作就是聚合所有 Realm 的结果信息封装至一个AuthenticationInfo 实例中，并将此信息返回，以此作为 Subject 的身份信息。Shiro 中定义了 3 种认证策略的实现：

认证策略类	描述
AtLeastOneSuccessfulStrategy	只要有一个（或更多）的 Realm 验证成功，那么认证将视为成功
FirstSuccessfulStrategy	第一个 Realm 验证成功，整体认证将视为成功，且后续 Realm 将被忽略
AllSuccessfulStrategy	所有 Realm 成功，认证才视为成功

ModularRealmAuthenticator 内置的认证策略默认实现是 AtLeastOneSuccessfulStrategy 方式。可以通过配置修改策略

2.2 配置修改

@Bean
public DefaultWebSecurityManager defaultWebSecurityManager(){
    //1 创建  defaultWebSecurityManager 对象
    DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
    //2 创建认证对象，并设置认证策略
    ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
    modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
    defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);
    //3 封装  myRealm 集合
    List<Realm> list = new ArrayList<>();
    list.add(myRealm);
    list.add(myRealm2);
    //4 将 myRealm 存入 defaultWebSecurityManager 对象
    defaultWebSecurityManager.setRealms(list);
    //5 返回
    return defaultWebSecurityManager;
}

3、remember me

3.1 实现原理

Shiro 提供了记住我（RememberMe）的功能，比如访问一些网站时，关闭了浏览器， 下次再打开时还是能记住你是谁， 下次访问时无需再登录即可访问。

基本流程

• 首先在登录页面选中 RememberMe 然后登录成功；如果是浏览器登录，一般会 把 RememberMe 的 Cookie 写到客户端并保存下来；
• 关闭浏览器再重新打开；会发现浏览器还是记住你的；
• 访问一般的网页服务器端，仍然知道你是谁，且能正常访问；
• 但是，如果我们访问电商平台时，如果要查看我的订单或进行支付时，此时还是需要再进行身份认证的，以确保当前用户还是你。

3.2 代码实现

过滤器可以参考：Shiro学习之过滤器详解

修改配置类，注意未认证的重定向在yml中进行配置

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置 SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1 创建  defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2 创建加密对象，并设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用  md5 加密
        matcher.setHashAlgorithmName("md5");
        //2.2 迭代加密次数
        matcher.setHashIterations(3);
        //3 将加密对象存储到  myRealm 中
        myRealm.setCredentialsMatcher(matcher);
        //4 将  myRealm 存入 defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealm(myRealm);
        //4.5 设置  rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //5 返回
        return defaultWebSecurityManager;
    }

    //cookie 属性设置
    public SimpleCookie rememberMeCookie() {
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        //cookie.setDomain(domain);
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30 * 24 * 60 * 60);
        return cookie;
    }

    //创建 Shiro 的  cookie 管理对象
    public CookieRememberMeManager rememberMeManager() {
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置 Shiro 内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin", "anon");
        definition.addPathDefinition("/myController/login", "anon");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**", "authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**", "user");
        return definition;
    }
}

修改controller

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("login")
    public String login(){
        return "login";
    }

    @GetMapping("userLogin")
    public String userLogin(String name, String pwd,
                            @RequestParam(defaultValue = "false")boolean rememberMe,
                            HttpSession session){
        //1获取subject对象
        Subject subject  = SecurityUtils.getSubject();
        //2封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name,pwd,rememberMe);
        //3调用login方法进行登录认证
        try {
            subject.login(token);
            //return "登录成功";
            session.setAttribute("user",token.getPrincipal().toString());
            return "main";

        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败");
            return "登录失败";
        }

    }

    //登录认证验证rememberMe
    @GetMapping("userLoginRm")
    public String userLogin(HttpSession session) {
        session.setAttribute("user","rememberMe");
        return "main";
    }
}

改造login页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>Shiro 登录认证h1>
<br>
<form action="/myController/userLogin">
    <div>用户名：<input type="text" name="name" value="">div>
    <div>密码：<input type="password" name="pwd" value="">div>
    <div>记住用户：<input type="checkbox" name="rememberMe" value="true">div>
    <div><input type="submit" value="登录">div>
form>
body>
html>

4、用户注销

用户登录后，配套的有登出操作。直接通过Shiro过滤器即可实现登出，首先修改main.html

<body>
<h1>Shiro 登录认证后主页面h1> 
<br>
登录用户为：<span th:text="${session.user}">span> 
<br>
<a href="/logout">登出a> 
body>

配置类中添加logout过滤器

@Bean
public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){ 
    DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
    //设置不认证可以访问的资源
    definition.addPathDefinition("/myController/userLogin","anon"); 
    definition.addPathDefinition("/myController/login","anon"); 
    //配置登出过滤器
    definition.addPathDefinition("/logout","logout"); 
    //设置需要进行登录认证的拦截范围
    definition.addPathDefinition("/**","authc"); 
    //添加存在用户的过滤器（rememberMe） 
    definition.addPathDefinition("/**","user"); 
    return  definition;
}

5、授权、角色认证

用户登录后，需要验证是否具有指定角色指定权限。Shiro也提供了方便的工具进行判断。这个工具就是Realm的doGetAuthorizationInfo方法进行判断，触发权限判断的有两种方式

• 在页面中通过shiro:属性判断
• 在接口服务中通过注解@Requires进行判断

5.1 后端接口服务注解

通过给接口服务方法添加注解可以实现权限校验，可以加在控制器方法上，也可以加
在业务方法上，一般加在控制器方法上。常用注解如下：

• @RequiresAuthentication

  验证用户是否登录，等同于方法subject.isAuthenticated()

  @RequiresUser

  验证用户是否被记忆： 登录认证成功subject.isAuthenticated()为true ；登录后被记忆subject.isRemembered()为true

• @RequiresGuest

  验证是否是一个guest的请求，是否是游客的请求 ，此时subject.getPrincipal()为null

• @RequiresRoles

  验证subject是否有相应角色，有角色访问方法，没有则会抛出异常 AuthorizationException。例如：@RequiresRoles("aRoleName") void someMethod(); 只有subject有aRoleName角色才能访问方法someMethod()

• @RequiresPermissions

  验证subject是否有相应权限，有权限访问方法，没有则会抛出异常 AuthorizationException。

  例如：@RequiresPermissions ("file:read","wite:aFile.txt") void someMethod();subject必须同时含有file:read和wite:aFile.txt权限才能访问方someMethod()

5.2 授权验证-获取角色验证

首先添加数据库

CREATE TABLE `role` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
  `name` VARCHAR(30) DEFAULT NULL COMMENT '角色名',
  `desc` VARCHAR(50) DEFAULT NULL COMMENT '描述',
  `realname` VARCHAR(20) DEFAULT NULL COMMENT '角色显示名', 
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色表';

CREATE TABLE `role_user` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
  `uid` BIGINT(20)  DEFAULT NULL COMMENT '用户  id',
  `rid` BIGINT(20)  DEFAULT NULL COMMENT '角色  id', 
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色用户映射表';

mapper

@Repository
public interface UserMapper extends BaseMapper<User> {

    @Select("SELECT NAME FROM role WHERE id IN (SELECT rid FROM role_user WHERE uid=(SELECT id FROM USER WHERE NAME=#{principal}))")
    List<String> getUserRoleInfoMapper(@Param("principal") String principal);
}

service服务实现类

@Override
public List<String> getUserRoleInfo(String principal) { 
    return userMapper.getUserRoleInfoMapper(principal);
}

MyRealm 授权认证方法改造

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("进入自定义授权方法"); 
    //获取当前用户身份信息
    String principal = principalCollection.getPrimaryPrincipal().toString();
    //调用接口方法获取用户的角色信息
    List<String> roles = userService.getUserRoleInfo(principal); 
    System.out.println("当前用户角色信息："+roles);
    //创建对象，存储当前登录的用户的权限和角色
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(); 
    //存储角色,测试的话可以直接塞String的角色
    info.addRoles(roles);
    //返回 
    return info;
}

最后controller添加授权方法，在mian.html添加测试授权-角色验证测试链接即可进行测试(数据库数据自行添加)

//登录认证验证角色
@RequiresRoles("admin")
@GetMapping("userLoginRoles")
@ResponseBody
public String userLoginRoles(){
    System.out.println("登录认证验证角色");
    return "验证角色成功";
}

5.3 授权验证-获取权限验证

创建权限数据表

CREATE TABLE `permissions` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
  `name` VARCHAR(30) DEFAULT NULL COMMENT '权限名',
  `info` VARCHAR(30) DEFAULT NULL COMMENT '权限信息', 
  `desc` VARCHAR(50) DEFAULT NULL COMMENT '描述', 
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='权限表';

CREATE TABLE `role_ps` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
  `rid` BIGINT(20)  DEFAULT NULL COMMENT '角色  id',
  `pid` BIGINT(20)  DEFAULT NULL COMMENT '权限  id', 
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色权限映射表';

创建方法

//Mapper类
@Select({
        ""
})
List<String> getUserPermissionInfoMapper(@Param("roles")List<String> roles);


// Service层
@Override
public List<String> getUserPermissionInfo(List<String> roles) { 
    return userMapper.getUserPermissionInfoMapper(roles);
}

修改MyRealm配置类

//自定义授权方法：获取当前登录用户权限信息，返回给 Shiro 用来进行授权对比
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("进入自定义授权方法");
    //获取当前用户身份信息
    String principal = principalCollection.getPrimaryPrincipal().toString();
    //调用接口方法获取用户的角色信息
    List<String> roles = userService.getUserRoleInfo(principal);
    System.out.println("当前用户角色信息："+roles);
    //调用接口方法获取用户角色的权限信息
    List<String> permissions = userService.getUserPermissionInfo(roles);
    System.out.println("当前用户权限信息："+permissions);
    //创建对象，存储当前登录的用户的权限和角色
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //存储角色
    info.addRoles(roles);
    //存储权限信息
    info.addStringPermissions(permissions);
    //返回 
    return info;
}

controller层

//登录认证验证权限
@RequiresPermissions("user:delete")
@GetMapping("userPermissions")
@ResponseBody
public String userLoginPermissions(){
    System.out.println("登录认证验证权限");
    return "验证权限成功";
}

修改main.html文件

<body>
<h1>Shiro 登录认证后主页面h1> 
<br>
登录用户为：<span th:text="${session.user}">span> 
<br>
<a href="/logout">登出a> 
<br>
<a href="/myController/userLoginRoles">测试授权-角色验证a> 
<br>
<a href="/myController/userPermissions">测试授权-权限验证a> 
body>

5.4 权限验证异常处理类

@ControllerAdvice
public class PermissionsException {
    @ResponseBody
    @ExceptionHandler(UnauthorizedException.class)
    public String unauthorizedException(Exception e){
        return "无权限";
    }

    @ResponseBody
    @ExceptionHandler(AuthorizationException.class)
    public String authorizationException(Exception e){
        return "权限认证失败";
    }

}

5.5 前端页面授权验证

前端可以根据不同的权限显示不同的信息，首先添加依赖

<dependency>
    <groupId>com.github.theborakompanionigroupId> 
    <artifactId>thymeleaf-extras-shiroartifactId> 
    <version>2.0.0version>
dependency>

配置类，用于解析 thymeleaf 中的 shiro:相关属性

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

Thymeleaf 中常用的 shiro:属性

<shiro:guest>
shiro:guest>


<shiro:user> 
shiro:user>


<shiro:authenticated>
shiro:authenticated>


<shiro:notAuthenticated>
shiro:notAuthenticated>


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


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


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


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


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


<shiro:hasPermission name="user:create"> 
shiro:hasPermission>

6、缓存管理

6.1 缓存工具EhCache

EhCache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存，Java EE和轻量级容器。可以和大部分Java项目无缝整合，例如：Hibernate中的缓存就是基于EhCache实现的。EhCache支持内存和磁盘存储，默认存储在内存中，如内存不够时把缓存数据同步到磁盘中。EhCache支持基于Filter的Cache实现，也支持Gzip压缩算法。

EhCache直接在JVM虚拟机中缓存，速度快，效率高；EhCache缺点是缓存共享麻烦，集群分布式应用使用不方便

6.2 Ehcache简单搭建

引入依赖

<dependency>
    <groupId>net.sf.ehcachegroupId>
    <artifactId>ehcacheartifactId>
    <version>2.6.11version>
    <type>pomtype>
dependency>

创建配置文件

<ehcache>
    
    <diskStore path="java.io.tmpdir/ehcache"/>
    
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    defaultCache>

    
    <cache name="HelloWorldCache"
           maxElementsInMemory="1000"
           eternal="false"
           timeToIdleSeconds="5"
           timeToLiveSeconds="5"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"/>

    
    

ehcache>

测试类

public static void main(String[] args) {
    //获取编译目录下的资源的流对象
    InputStream input = TestEH.class.getClassLoader().getResourceAsStream("ehcache.xml");
    //获取EhCache的缓存管理对象
    CacheManager cacheManager = new CacheManager(input);
    //获取缓存对象
    Cache cache = cacheManager.getCache("HelloWorldCache");
    //创建缓存数据
    Element element = new Element("name","shawn");
    //存入缓存
    cache.put(element);
    //从缓存中取出数据输出
    Element element1 = cache.get("name");
    System.out.println("缓存中数据 = " + element1.getObjectValue());
}

6.3 Shiro整合EhCache

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-ehcacheartifactId>
    <version>1.10.0version>
dependency>

<dependency>
    <groupId>commons-iogroupId>
    <artifactId>commons-ioartifactId>
    <version>2.11.0version>
dependency>

然后在resources下添加配置文件ehcache/ehcache-shiro.xml

<ehcache name="ehcache" updateCheck="false"> 
    <diskStore path="java.io.tmpdir"/> 
    <defaultCache
            maxEntriesLocalHeap="1000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="false">
    defaultCache> 
    <cache name="loginRolePsCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true"/>
ehcache>

最后修改Shiro配置

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2创建加密对象，设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4将myRealm存入defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealm(myRealm);
        //4.5设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //4.6设置缓存管理器
        defaultWebSecurityManager.setCacheManager(getEhCacheManager());

        //5返回
        return defaultWebSecurityManager;
    }

    //缓存管理器
    public EhCacheManager getEhCacheManager(){
        EhCacheManager ehCacheManager = new EhCacheManager();
        InputStream is =null;
        try {
            is = ResourceUtils.getInputStreamForPath("classpath:ehcache/ehcache-shiro.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        CacheManager cacheManager = new CacheManager(is);
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

    //cookie 属性设置
    public SimpleCookie rememberMeCookie() {
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        //cookie.setDomain(domain);
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30 * 24 * 60 * 60);
        return cookie;
    }

    //创建 Shiro 的  cookie 管理对象
    public CookieRememberMeManager rememberMeManager() {
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置 Shiro 内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/myController/login","anon");
        //配置登出过滤器
        definition.addPathDefinition("/logout","logout");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return  definition;
    }
}

最后访问权限测试，发现其成功缓存

7、会话管理

7.1 SessionManager

会话管理器，负责创建和管理用户的会话（Session）生命周期，它能够在任何环境中在本地管理用户会话，即使没有Web/Servlet/EJB容器，也一样可以保存会话。默认情况下，Shiro会检测当前环境中现有的会话机制（比如Servlet容器）进行适配，如果没有（比如独立应用程序或者非Web环境），它将会使用内置的企业会话管理器来提供相应的会话管理服务，其中还涉及一个名为SessionDAO的对象。SessionDAO负责Session的持久化操作（CRUD），允许Session数据写入到后端持久化数据库

7.2 会话管理实现

SessionManager由SecurityManager管理。Shiro提供了三种实现

• DefaultSessionManager：用于JavaSE环境
• ServletContainerSessionManager：用于web环境，直接使用Servlet容器的会话
• DefaultWebSessionManager：用于web环境，自己维护会话（不使用Servlet容器的会话管理）

7.3 获得session方式

• 实现

 Session session = SecurityUtils.getSubject().getSession();
 session.setAttribute("key","value") 

• 说明

  Controller中的request，在shiro过滤器中的doFilerInternal方法，被包装成ShiroHttpServletRequest。

  SecurityManager和SessionManager会话管理器决定session来源于ServletRequest还是由Shiro管理的会话。 无论是通过request.getSession或subject.getSession获取到session，操作session，两者都是等价的。

---

参考：

shiro框架如何保持登录状态

https://www.bilibili.com/video/BV11e4y1n7BH