Shiro安全框架

Shiro安全框架

  • 一、入门概述
    • 1.1.Shiro 与SpringSecurity 的对比 :
    • 1.2.功能简介
    • 1.3.原理
  • 二、基本使用
    • 2.1.环境准备
      • 2.1.1.创建Maven工程
      • 2.1.2.添加相关依赖
    • 2.2.创建ini文件
    • 2.3.登录认证
      • 2.3.1.登录认证概念
      • 2.3.2.登录认证基本流程
      • 2.3.3.登录认证实例 --测试类
    • 2.4.角色、授权
      • 2.4.1.授权概念
      • 2.4.2.授权方式
      • 2.4.3.授权流程
      • 2.4.4.授权实例
        • 2.4.4.1.获取角色信息
          • 2.4.4.1.1.给shiro.ini增加角色配置
          • 2.4.4.1.2.给例子添加代码,沟通过hasRole()判断用户是否有指定角色
        • 2.4.4.2.判断权限信息
          • 2.4.4.2.1.给shiro.ini增加权限配置
          • 2.4.4.2.2.判断用户是否有指定权限
    • 2.5.shiro加密
      • 2.5.1.使用Shiro进行密码加密
    • 2.6.shiro自定义登录认证
      • 2.6.1.在shiro.ini中添加配置信息
      • 2.6.2.自定义登录认证
      • 2.6.3.测试类
      • 2.6.4.运行结果
  • 三、shiro与Spring Boot整合
    • 3.1.框架整合
      • 3.1.1.创建项目
      • 3.1.2.添加依赖
      • 3.1.3.添加配置文件application.yml
      • 3.1.4.添加启动类
    • 3.2.登录认证实现
      • 3.2.1.后端接口服务实现
        • 3.2.1.1.创建库表
        • 3.2.1.2.创建实体类 User
        • 3.2.1.3.创建 UserMapper接口
        • 3.2.1.4.创建 service
        • 3.2.1.5.自定义 realm
        • 3.2.1.6.编写配置类
        • 3.2.1.7.实现controller
        • 3.2.1.8.测试
      • 3.2.2.实现前端页面【Shiro整合Thymeleaf】
        • 3.2.2.1.确认依赖
        • 3.2.2.2.添加login页面
        • 3.2.2.3.添加main页面
        • 3.2.2.4.添加controller方法,改造认证方法
        • 3.2.2.5.修改配置文件
        • 3.2.2.6.修改配置类
        • 3.2.2.7.启动,访问测试
    • 3.3.多个realm的认证策略设置
      • 3.3.1.多个realm实现原理
      • 3.3.2.多个realm代码实现
    • 3.4.remember me 功能
      • 3.4.1.基本流程
      • 3.4.2.代码实现
        • 3.4.2.1.修改配置类
        • 3.4.2.2.修改controller
        • 3.4.2.3.改造页面login.html
        • 3.4.2.4.测试
    • 3.5.用户登录认证后登出
      • 3.5.1.修改登录后的main.html
      • 3.5.2.修改配置类,添加logout过滤器
      • 3.5.3.测试
    • 3.6.授权、角色认证
      • 3.6.1.授权
      • 3.6.2.后端接口服务注解
      • 3.6.3.授权验证-没有角色无法访问
        • 3.6.3.1.添加controller 方法,并添加验证角色注解
        • 3.6.3.2.修改main.html
        • 3.6.3.3.修改MyRealm方法
        • 3.6.3.4.测试
        • 3.6.3.5.授权验证-获取角色进行验证
        • 3.6.3.6.测试
      • 3.6.4.授权认证
        • 3.6.4.1.确认库表【角色表、角色和用户映射关系】
        • 3.6.4.2.查询sql
        • 3.6.4.3.Mapper方法
        • 3.6.4.4.service实现
        • 3.6.4.5.MyRealm方法改造
        • 3.6.4.6.启动登录测试
      • 3.6.5.授权验证-获取权限进行验证
        • 3.6.5.1.确认库表
        • 3.6.5.2.查询sql
        • 3.6.4.3.Mapper方法
        • 3.6.4.4.service实现
        • 3.6.4.5.MyRealm方法改造
        • 3.6.4.6.添加controller方法
        • 3.6.4.7.改造main.html
        • 3.6.4.8.启动登录测试
      • 3.6.6.授权验证-异常处理
        • 3.6.6.1.创建认证异常处理类,使用@ControllerAdvice 加@ExceptionHandler实现特殊异常处理。
        • 3.6.6.2.启动测试,用李四登录测试
      • 3.6.7.前端页面权限验证
        • 3.6.7.1.添加依赖-配置Thymeleaf与Shiro的整合依赖
        • 3.6.7.2.配置类添加新配置--用于解析 thymeleaf中的 shiro:相关属性
        • 3.6.7.3.Thymeleaf中常用的shiro:属性
        • 3.6.7.4.改造main.html
        • 3.6.7.5.测试
      • 3.6.8.源码
        • 3.6.8.1.pom.xml
        • 3.6.8.2.application.yml
        • 3.6.8.3.ShiroConfig.java
        • 3.6.8.4.User.java
        • 3.6.8.5.UserMapper.java
        • 3.6.8.6.UserService.java
        • 3.6.8.7.UserServiceImpl.java
        • 3.6.8.8.MyRealm.java
        • 3.6.8.9.PermissionsException.java
        • 3.6.8.10.MyController.java
        • 3.6.8.11.ShiroMD5.java
        • 3.6.8.12.login.html
        • 3.6.8.13.main.html
        • 3.6.8.14.数据库和表
    • 3.7.实现缓存
      • 3.7.1.缓存工具EhCache
      • 3.7.2.EhCache搭建使用
        • 3.7.2.1.创建模块
        • 3.7.2.2.添加依赖
        • 3.7.2.3.添加配置文件ehcache.xml
        • 3.7.2.4.创建测试类,操作缓存
      • 3.7.3.Shiro整合EhCache
        • 3.7.3.1.添加依赖
        • 3.7.3.2.在resources下添加配置文件 ehcache/ehcache-shiro.xml
        • 3.7.3.3.修改配置类ShiroConfig
        • 3.7.3.4.启动测试
    • 3.8.会话管理
      • 3.8.1.SessionManager
      • 3.8.2.会话管理实现
      • 3.8.3.获得session方式
        • 3.8.3.1.实现
        • 3.8.3.2.说明
  • endl

一、入门概述

1.1.Shiro 与SpringSecurity 的对比 :

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

1.2.功能简介

Shiro安全框架_第1张图片
(1)Authentication:身份认证/登录,验证用户是不是拥有相应的身份;

(2)Authorization:授权,即权限验证,验证某个已认证的用户是否拥有某个权限;即判断用 户是否能进行什么操作,如:验证某个用户是否拥有某个角色。或者细粒度的验证某个用户 对某个资源是否具有某个权限;

(3)Session Manager:会话管理,即用户登录后就是一次会话,在没有退出之前,它的所有 信息都在会话中;会话可以是普通 JavaSE 环境,也可以是 Web 环境的;

(4)Cryptography:加密,保护数据的安全性,如密码加密存储到数据库,而不是明文存储;

(5)Web Support:Web 支持,可以非常容易的集成到 Web 环境;

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

(7)Concurrency:Shiro 支持多线程应用的并发验证,即如在一个线程中开启另一个线程,能把权限自动传播过去;

(8)Testing:提供测试支持;

(9)Run As:允许一个用户假装为另一个用户(如果他们允许)的身份进行访问;

(10)Remember Me:记住我,这个是非常常见的功能,即一次登录后,下次再来的话不用登录了

1.3.原理

Shiro安全框架_第2张图片
(1)Subject:应用代码直接交互的对象是 Subject,也就是说 Shiro 的对外 API 核心就是 Subject。Subject 代表了当前“用户”, 这个用户不一定是一个具体的人,与当前应用交互的任何东西都是 Subject,如网络爬虫, 机器人等;与 Subject 的所有交互都会委托给SecurityManager; Subject 其实是一个门面,SecurityManager 才是实际的执行者;

(2)SecurityManager:安全管理器;即所有与安全有关的操作都会与 SecurityManager交互;且其管理着所有 Subject;可以看出它是 Shiro 的核心,它负责与 Shiro 的其他组件进行交互,它相当于 SpringMVC 中 DispatcherServlet 的角色

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

二、基本使用

2.1.环境准备

2.1.1.创建Maven工程

Shiro安全框架_第3张图片

2.1.2.添加相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>shiro_login</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

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

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

    </dependencies>

</project>

2.2.创建ini文件

Shiro获取权限相关信息可以通过数据库获取,也可以通过ini配置文件获取

  • shiro.ini
[users]
zhangsan=z3
lisi=123456

Shiro安全框架_第4张图片

2.3.登录认证

2.3.1.登录认证概念

(1)身份验证:一般需要提供如身份ID等一些标识信息来表明登录者的身份,如提供 email,用户名/密码来证明。

(2)在shiro中,用户需要提供principals(身份)和credentials(证明)给shiro,从而应用能验证用户身份:

(3)principals:身份,即主体的标识属性,可以是任何属性,如用户名、邮箱等,唯一即可。一个主体可以有多个principals,但只有一个Primary principals,一般是用户名/邮箱/手机号。

(4)credentials:证明/凭证,即只有主体知道的安全值,如密码/数字证书等。

(5)最常见的principals和credentials组合就是用户名/密码

2.3.2.登录认证基本流程

1)收集用户身份/凭证,即如用户名/密码

2)调用 Subject.login 进行登录,如果失败将得到相应 的 AuthenticationException 异常,根据异常提示用户错误信息;否则登录成功

3)创建自定义的 Realm 类,继承 org.apache.shiro.realm.AuthenticatingRealm类,实现 doGetAuthenticationInfo() 方法

Shiro安全框架_第5张图片

2.3.3.登录认证实例 --测试类

创建测试类,获取认证对象,进行登录认证

Shiro安全框架_第6张图片

package com.orange.shirotest;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        //2.获取Subject对象
        //3.创建token对象,web应用用户名和密码从页面传递
        //4.完成登录

        //1.初始化获取SecurityManager
        IniSecurityManagerFactory 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("zhangsan", "z3");

        //4.完成登录
        try {
            subject.login(token);
            System.out.println("登录成功 success");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }
}

2.4.角色、授权

2.4.1.授权概念

1)授权,也叫访问控制,即在应用中控制谁访问哪些资源(如访问页面/编辑数据/页面操作等)。在授权中需了解的几个关键对象:主体(Subject)、资源(Resource)、权限 (Permission)、角色(Role)。

2)主体(Subject):访问应用的用户,在 Shiro 中使用 Subject 代表该用户。用户只有授权 后才允许访问相应的资源。

3)资源(Resource):在应用中用户可以访问的 URL,比如访问 JSP 页面、查看/编辑某些 数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。

4)权限(Permission):安全策略中的原子授权单位,通过权限我们可以表示在应用中用户 有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源,如:访问用 户列表页面查看/新增/修改/删除用户数据(即很多时候都是CRUD(增查改删)式权限控制)等。权限代表了用户有没有操作某个资源的权利,即反映在某个资源上的操作允不允许。

5)Shiro 支持粗粒度权限(如用户模块的所有权限)和细粒度权限(操作某个用户的权限, 即实例级别的)

6)角色(Role):权限的集合,一般情况下会赋予用户角色而不是权限,即这样用户可以拥有一组权限,赋予权限时比较方便。典型的如:项目经理、技术总监、CTO、开发工程师等 都是角色,不同的角色拥有一组不同的权限

2.4.2.授权方式

(1)编程式:通过写if/else 授权代码块完成

Subject subject = SecurityUtils.getSubject();
if(subject.hasRole("admin")){
	//有权限
}else{
	//无权限
}

(2)注解式:通过在执行的Java方法上放置相应的注解完成,没有权限将抛出相 应的异常

@RequiresRoles("admin")
public void hello(){
	//有权限
}

(3)JSP/GSP 标签:在JSP/GSP 页面通过相应的标签完成

<shiro:hasRole name="admin">
<!--有权限-->
</shiro:hasRole>

2.4.3.授权流程

(1)首先调用Subject.isPermitted*/hasRole*接口,其会委托给SecurityManager,而SecurityManager接着会委托给 Authorizer;

(2)Authorizer是真正的授权者,如果调用如isPermitted(“user:view”),其首先会通过PermissionResolver把字符串转换成相应的Permission实例;

(3)在进行授权之前,其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限;

(4)Authorizer会判断Realm的角色/权限是否和传入的匹配,如果有多个Realm,会委托给ModularRealmAuthorizer进行循环判断,如果匹配如isPermitted*/hasRole* 会返回true,否则返回false表示授权失败

2.4.4.授权实例

2.4.4.1.获取角色信息
2.4.4.1.1.给shiro.ini增加角色配置
[users]
zhangsan=z3,role1,role2
lisi=123456
2.4.4.1.2.给例子添加代码,沟通过hasRole()判断用户是否有指定角色
package com.orange.shirotest;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        //2.获取Subject对象
        //3.创建token对象,web应用用户名和密码从页面传递
        //4.完成登录
        //5.判断角色

        //1.初始化获取SecurityManager
        IniSecurityManagerFactory 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("zhangsan", "z3");

        //4.完成登录
        try {
            subject.login(token);
            System.out.println("登录成功 success");

            //5.判断角色
            boolean hasRole = subject.hasRole("role1");
            System.out.println("是否拥有role1角色 = " + hasRole);

        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }
}
2.4.4.2.判断权限信息
2.4.4.2.1.给shiro.ini增加权限配置
[users]
zhangsan=z3,role1,role2
lisi=123456

[roles]
role1=user:insert,user:select
2.4.4.2.2.判断用户是否有指定权限
package com.orange.shirotest;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        //2.获取Subject对象
        //3.创建token对象,web应用用户名和密码从页面传递
        //4.完成登录
        //5.判断角色
        //6.判断权限

        //1.初始化获取SecurityManager
        IniSecurityManagerFactory 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("zhangsan", "z3");

        //4.完成登录
        try {
            subject.login(token);
            System.out.println("登录成功 success");

            //5.判断角色
            boolean hasRole = subject.hasRole("role1");
            System.out.println("是否拥有role1角色 = " + hasRole);

            //6.判断权限
            boolean permitted = subject.isPermitted("user:insert");
            System.out.println("是否拥有user.insert权限 = " + permitted);
            //也可以用checkPermission方法,但没有返回值,没权限抛出AuthenticationException
            //subject.checkPermission("user:select11");
            subject.checkPermission("user:select");

        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }
}
登录成功 success
是否拥有role1角色 = true
是否拥有user:insert权限 = true

2.5.shiro加密

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

2.5.1.使用Shiro进行密码加密

package com.orange.shirotest;

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

public class ShiroMD5 {
    public static void main(String[] args) {
        //密码明文
        String password = "z3";

        //使用MD5加密
        Md5Hash md5Hash = new Md5Hash(password);
        System.out.println("MD5加密 = " + md5Hash);

        ///带盐的md5加密,盐就是在密码明文后拼接新字符串,然后再进行加密
        Md5Hash md5Hash2 = new Md5Hash(password, "salt");
        System.out.println("带盐 MD5加密 = " + md5Hash2.toHex());

        //为了保证安全,避免被破解还可以多次迭代加密,保证数据安全
        Md5Hash md5Hash3 = new Md5Hash(password, "salt", 5);
        System.out.println("带盐 MD5 五次加密 = " + md5Hash3.toHex());

        //使用父类实现加密
        SimpleHash simpleHash = new SimpleHash("MD5", password, "salt", 5);
        System.out.println("父类 MD5 带盐五次加密 = " + simpleHash.toHex());

    }
}
MD5加密 = a61d1457beb4684e254ce60379c8ae7b
带盐 MD5加密 = dd4611daf1e40eff99b9fdcadbd22674
带盐 MD5 五次加密 = 929a3a60ae40eb8719bccdba171924e8
父类 MD5 带盐五次加密 = 929a3a60ae40eb8719bccdba171924e8

2.6.shiro自定义登录认证

Shiro默认的登录认证是不带加密的,如果想要实现加密认证需要自定义登录认证,自定义Realm。

2.6.1.在shiro.ini中添加配置信息

[main]
md5CredentialsMatcher=org.apache.shiro.authc.credential.Md5CredentialsMatcher
# 加盐迭代5次
md5CredentialsMatcher.hashIterations=5

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

[users]
#zhangsan=z3,role1,role2
zhangsan=929a3a60ae40eb8719bccdba171924e8,role1,role2
lisi=123456

[roles]
#角色role1对资源user拥有insert、select权限
role1=user:insert,user:select

2.6.2.自定义登录认证

package com.orange.shirotest;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.realm.AuthenticatingRealm;
import org.apache.shiro.util.ByteSource;

public class MyRealm extends AuthenticatingRealm {

    //自定义的登录认证方法,Shiro的login方法底层会调用该类的认证方法完成登录认证
    //需要配置自定义的realm生效,在 ini文件中配置 或 Springboot中配置
    //该方法只是获取进行对比的信息,认证逻辑还是按照 Shiro的底层认证逻辑完成认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1获取身份信息
        //2获取凭证信息
        //3获取数据库中存储的用户信息
        //3.1数据库存储的加盐迭代 5次密码
        //3.2创建封装了校验逻辑的对象,将要比较的数据给该对象

        //1获取身份信息
        String principal = authenticationToken.getPrincipal().toString();

        //2获取凭证信息
        String password = new String((char[]) authenticationToken.getCredentials());
        System.out.println("认证用户信息: \n姓名:" + principal + "\n密码:" + password);


        //3获取数据库中存储的用户信息
        if (principal.equals("zhangsan")) {
            //3.1数据库存储的加盐迭代 5次密码
            String pwdInfo = new Md5Hash(password, "salt", 5).toString();
            System.out.println("加盐迭代 5次密码 = " + pwdInfo);
            //3.2创建封装了校验逻辑的对象,将要比较的数据给该对象
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    pwdInfo,
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );

            return info;
        }
        return null;
    }
}

2.6.3.测试类

package com.orange.shirotest;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        //2.获取Subject对象
        //3.创建token对象,web应用用户名和密码从页面传递
        //4.完成登录
        //5.判断角色
        //6.判断权限

        //1.初始化获取SecurityManager
        IniSecurityManagerFactory 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("zhangsan", "z3");

        //4.完成登录
        try {
            subject.login(token);
            System.out.println("登录成功 success");

            //5.判断角色
            boolean hasRole = subject.hasRole("role1");
            System.out.println("是否拥有role1角色 = " + hasRole);
            System.out.println(
                    Arrays.toString(subject.hasRoles(Arrays.asList("role1","role2")))
            );

            //6.判断权限
            boolean permitted = subject.isPermitted("user:insert");
            System.out.println("是否拥有user:insert权限 = " + permitted);
            //也可以用checkPermission方法,但没有返回值,没权限抛出AuthenticationException
            //subject.checkPermission("user:select11");
            subject.checkPermission("user:select");

        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }finally {
            // 7:判断是否登录成功
            System.out.println("是否登录成功:"+subject.isAuthenticated());
            subject.logout();
            System.out.println("是否登录成功:"+subject.isAuthenticated());
        }
    }
}

2.6.4.运行结果

认证用户信息: 
姓名:zhangsan
密码:z3
加盐迭代 5次密码 = 929a3a60ae40eb8719bccdba171924e8
登录成功 success
是否拥有role1角色 = false
[false, false]
是否拥有user:insert权限 = false
是否登录成功:true
是否登录成功:false
Exception in thread "main" org.apache.shiro.authz.UnauthorizedException: Subject does not have permission [user:select]
	at org.apache.shiro.authz.ModularRealmAuthorizer.checkPermission(ModularRealmAuthorizer.java:323)
	at org.apache.shiro.mgt.AuthorizingSecurityManager.checkPermission(AuthorizingSecurityManager.java:137)
	at org.apache.shiro.subject.support.DelegatingSubject.checkPermission(DelegatingSubject.java:209)
	at com.orange.shirotest.ShiroRun.main(ShiroRun.java:49)

三、shiro与Spring Boot整合

3.1.框架整合

3.1.1.创建项目

Shiro安全框架_第7张图片
Shiro安全框架_第8张图片
Shiro安全框架_第9张图片

3.1.2.添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.orange</groupId>
    <artifactId>shiro_springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.2.1.RELEASE</version>
    </parent>

    <dependencies>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>1.9.0</version>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

</project>

3.1.3.添加配置文件application.yml

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.jdbc.Driver
    url: jdbc:mysql://192.168.229.141:3306/shirodb?characterEncoding=utf-8&&useSSL=false
    username: root
    password: 123456
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

shiro:
  loginUrl: /myController/login

3.1.4.添加启动类

@SpringBootApplication
@MapperScan("com.orange.shiro.mapper")
public class ShiroApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShiroApplication.class, args);
    }
}

Shiro安全框架_第10张图片

3.2.登录认证实现

访问数据库获取用户信息,实现登录认证

3.2.1.后端接口服务实现

Shiro安全框架_第11张图片

3.2.1.1.创建库表
CREATE DATABASE IF NOT EXISTS shirodb CHARACTER SET utf8mb4;

show databases;

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=1 DEFAULT CHARSET=utf8 COMMENT='用户表';

insert into user(name,pwd)values
('zhangsan','564aef3cf9967536bc104b4089c5e049'),
('lisi','564aef3cf9967536bc104b4089c5e049');

select * from user;

Shiro安全框架_第12张图片
Shiro安全框架_第13张图片
Shiro安全框架_第14张图片

Shiro安全框架_第15张图片

3.2.1.2.创建实体类 User
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
    private Integer rid;
}
3.2.1.3.创建 UserMapper接口
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.orange.shiro.entiy.User;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper extends BaseMapper<User> {
}
3.2.1.4.创建 service
public interface UserService {
    //用户登录
    User getUserInfoByName(String name);
}
@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;
    }
}
3.2.1.5.自定义 realm
package com.orange.shiro.realm;

import com.orange.shiro.entiy.User;
import com.orange.shiro.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        //2.调用应用层获取用户信息(数据库)
        //3.非空判断,将数据封装返回
        
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用应用层获取用户信息(数据库)
        User user = userService.getUserInfoByName(name);
        //3.非空判断,将数据封装返回
        if (user != null) {
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

3.2.1.6.编写配置类
@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //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;
    }

}
3.2.1.7.实现controller
@Controller
@RequestMapping("myController")
public class MyController {

    @GetMapping("userLogin")
    @ResponseBody
    public String userLogin(String name, String pwd) {
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd);
        //3.调用login方法进行登录认证
        try {
            subject.login(token);
            return "登录成功";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败");
            return "登录失败";
        }
    }
}
3.2.1.8.测试
http://localhost:8080/myController/userLogin?name=zhangsan&pwd=123456

Shiro安全框架_第16张图片
Shiro安全框架_第17张图片

3.2.2.实现前端页面【Shiro整合Thymeleaf】

Shiro安全框架_第18张图片

3.2.2.1.确认依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
3.2.2.2.添加login页面
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</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="submit" value="登录"></div>
</form>

</body>
</html>
3.2.2.3.添加main页面
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
</body>
</html>
3.2.2.4.添加controller方法,改造认证方法
@Controller
@RequestMapping("myController")
public class MyController {
    
    //跳转到登录页面
    @GetMapping("login")
    public String login() {
        return "login";
    }

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

}
3.2.2.5.修改配置文件
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.jdbc.Driver
    url: jdbc:mysql://192.168.229.141:3306/shirodb?characterEncoding=utf-8&&useSSL=false
    username: root
    password: 123456
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

# 指定登录页面路径
shiro:
  loginUrl: /myController/login
3.2.2.6.修改配置类
@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //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;
    }

}
3.2.2.7.启动,访问测试
http://localhost:8080/myController/login

Shiro安全框架_第19张图片
Shiro安全框架_第20张图片

3.3.多个realm的认证策略设置

3.3.1.多个realm实现原理

当应用程序配置多个 Realm时,例如:用户名密码校验、手机号验证码校验等等。
Shiro的ModularRealmAuthenticator 会使用内部的AuthenticationStrategy组件判断认证是成功还是失败。
AuthenticationStrategy是一个无状态的组件,它在身份验证尝试中被询问4 次(这4次交互所需的任何必要的状态将被作为方法参数)

(1)在所有Realm被调用之前
(2)在调用Realm的getAuthenticationInfo方法之前
(3)在调用Realm的getAuthenticationInfo 方法之后
(4)在所有Realm被调用之后

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

Shiro中定义了3种认证策略的实现:

AuthenticationStrategy class 描述
AtLeastOneSuccessfulStrategy 只要有一个(或更多)的 Realm 验证成功,那么认证将视为成功
FirstSuccessfulStrategy 第一个 Realm 验证成功,整体认证将视为成功,且后续 Realm 将被忽略
AllSuccessfulStrategy 所有 Realm 成功,认证才视为成功

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

3.3.2.多个realm代码实现

@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //创建认证对象,并设置认证策略
        ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
        defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);
        
        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);

        //封装myRealm集合
        ArrayList<Realm> list = new ArrayList<>();
        list.add(myRealm);
        //list.add(myRealm2);
        
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealms(list);
        //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;
    }

}

3.4.remember me 功能

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

3.4.1.基本流程

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

3.4.2.代码实现

3.4.2.1.修改配置类
@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //创建认证对象,并设置认证策略
        ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
        defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);

        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);

        //封装myRealm集合
        ArrayList<Realm> list = new ArrayList<>();
        list.add(myRealm);
        //list.add(myRealm2);

        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealms(list);
        //4.1设置
        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());
        //AES的秘钥一定要是16位秘钥
        //Caused by: java.security.InvalidKeyException: Invalid AES key length: 10 bytes
        //cookieRememberMeManager.setCipherKey("1234567890".getBytes());
        cookieRememberMeManager.setCipherKey("1234567890123456".getBytes());
        return cookieRememberMeManager;
    }

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

        //添加存在的用户过滤器rememberMe
        definition.addPathDefinition("/**","user");

        //返回
        return definition;
    }

}
3.4.2.2.修改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";
    }

}
3.4.2.3.改造页面login.html
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</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>
3.4.2.4.测试

通过地址访问userLoginRm

http://localhost:8080/myController/userLoginRm

过滤器拦截跳回登录页面 

Shiro安全框架_第21张图片

登录勾选记住用户
Shiro安全框架_第22张图片
重新访问userLoginRm

http://localhost:8080/myController/userLoginRm

Shiro安全框架_第23张图片

3.5.用户登录认证后登出

用户登录后,配套的有登出操作。直接通过Shiro过滤器即可实现登出

3.5.1.修改登录后的main.html

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
<br>
<a href="/logout">登出</a>
</body>
</html>

3.5.2.修改配置类,添加logout过滤器

    //配置 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;
    }

3.5.3.测试

http://localhost:8080/myController/userLoginRm

Shiro安全框架_第24张图片

3.6.授权、角色认证

Shiro安全框架_第25张图片

3.6.1.授权

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

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

3.6.2.后端接口服务注解

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

常用注解如下:

  1. @RequiresAuthentication:验证用户是否登录,等同于方法subject.isAuthenticated()
  2. @RequiresUser:验证用户是否被记忆:
  • 登录认证成功subject.isAuthenticated()为true
  • 登录后被记忆subject.isRemembered()为true
  1. @RequiresGuest:验证是否是一个guest的请求,是否是游客的请求,此时subject.getPrincipal()为null
  2. @RequiresRoles:验证subject是否有相应角色,有角色访问方法,没有则会抛出异常AuthorizationException。
  • 例如:@RequiresRoles(“aRoleName”)
  • void someMethod();
  • 只有subject有aRoleName角色才能访问方法someMethod()
  1. @RequiresPermissions:验证subject是否有相应权限,有权限访问方法,没有则会抛出异常AuthorizationException。
  • 例如:@RequiresPermissions (“file:read”,”write:aFile.txt”)
  • void someMethod();
  • subject必须同时含有file:read和write:aFile.txt权限才能访问方法someMethod()

3.6.3.授权验证-没有角色无法访问

3.6.3.1.添加controller 方法,并添加验证角色注解
    //登录认证验证角色
    @RequiresRoles("admin")
    @GetMapping("userLoginRoles")
    @ResponseBody
    public String userLoginRoles() {
        System.out.println("登录认证验证角色");
        return "验证角色成功";
    }
3.6.3.2.修改main.html
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
<br>
<a href="/logout">登出</a>
<br>
<a href="/myController/userLoginRoles">测试授权</a>
</body>
</html>
3.6.3.3.修改MyRealm方法
    //自定义授权方法:获取当前登录用户权限信息,返回给 Shiro用来进行授权对比
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        return null;
    }
3.6.3.4.测试
http://localhost:8080/myController/userLoginRoles

Shiro安全框架_第26张图片
Shiro安全框架_第27张图片
Shiro安全框架_第28张图片

3.6.3.5.授权验证-获取角色进行验证
    //自定义授权方法:获取当前登录用户权限信息,返回给 Shiro用来进行授权对比
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.创建对象,封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //2.存储角色
        info.addRole("admin");
        //3.返回信息
        return info;
    }
3.6.3.6.测试
http://localhost:8080/myController/userLoginRoles

Shiro安全框架_第29张图片
Shiro安全框架_第30张图片

3.6.4.授权认证

3.6.4.1.确认库表【角色表、角色和用户映射关系】
show databases;
use shirodb;
show tables;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色表';

insert into `role` (`name`,`desc`,`realname`)values
('admin','所有权限','管理员'),
('userMag','用户管理权限','用户管理');

select * from role;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色用户映射表';

insert into `role_user` (`uid`,`rid`) values
(1,1),
(1,2),
(2,2);

select * from role_user;

Shiro安全框架_第31张图片
Shiro安全框架_第32张图片

3.6.4.2.查询sql

Shiro安全框架_第33张图片

根据用户名查询对应角色信息

select id from user where name = 'zhangsan';
select rid from role_user where uid = (select id from user where name = 'zhangsan');
select name from role where id in (select rid from role_user where uid = (select id from user where name = 'zhangsan'));

Shiro安全框架_第34张图片

3.6.4.3.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);
}

3.6.4.4.service实现
public interface UserService {
    //用户登录
    User getUserInfoByName(String name);
    //根据用户查询角色信息
    List<String> getUserRoleInfo(String principal);
}
@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;
    }

    //根据用户查询角色信息
    @Override
    public List<String> getUserRoleInfo(String principal) {
        return userMapper.getUserRoleInfoMapper(principal);
    }
}
3.6.4.5.MyRealm方法改造
    //自定义授权方法:获取当前登录用户权限信息,返回给 Shiro用来进行授权对比
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取当前用户的身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roles = userService.getUserRoleInfo(principal);
        System.out.println("当前用户角色信息 = " + roles);

        //3.创建对象,封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //4.存储角色
        info.addRoles(roles);
        //5.返回信息
        return info;
    }
3.6.4.6.启动登录测试
http://localhost:8080/myController/userLogin

Shiro安全框架_第35张图片
Shiro安全框架_第36张图片

3.6.5.授权验证-获取权限进行验证

获取权限验证和获取角色相类似

3.6.5.1.确认库表
show databases;
use shirodb;
show tables;

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=1 DEFAULT CHARSET=utf8 COMMENT='权限表';

insert into  `permissions` (`name`,`info`,`desc`) values
('删除用户','user:delete','删除用户'),
('新增用户','user:add','新增用户'),
('修改用户','user:edit','修改用户');

select * from permissions;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色权限映射表';

insert into  `role_ps`(`rid`,`pid`)values
(1,1),
(1,2),
(1,3);

select * from role_ps;

Shiro安全框架_第37张图片
Shiro安全框架_第38张图片

3.6.5.2.查询sql

Shiro安全框架_第39张图片

根据角色名查询对应权限信息

select id from role where name in('admin','userMag');
select pid from role_ps where rid in (select id from role where name in('admin','userMag'));
select info from permissions where id in (select pid from role_ps where rid in (select id from role where name in('admin','userMag')));

Shiro安全框架_第40张图片

3.6.4.3.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);

    //前后分别添加了,这是因为SQL中使用了动态sql标签
    @Select({""
    })
    List<String> getUserPermissionInfoMapper(@Param("roles") List<String> roles);
}
3.6.4.4.service实现
public interface UserService {
    //用户登录
    User getUserInfoByName(String name);

    //根据用户查询角色信息
    List<String> getUserRoleInfo(String principal);

    //获取用户角色权限信息
    List<String> getUserPermissionInfo(List<String> roles);
}
@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;
    }

    //根据用户查询角色信息
    @Override
    public List<String> getUserRoleInfo(String principal) {
        return userMapper.getUserRoleInfoMapper(principal);
    }

    //获取用户权限信息
    @Override
    public List<String> getUserPermissionInfo(List<String> roles) {
        return userMapper.getUserPermissionInfoMapper(roles);
    }
}
3.6.4.5.MyRealm方法改造
    //自定义授权方法:获取当前登录用户权限信息,返回给 Shiro用来进行授权对比
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取当前用户的身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roles = userService.getUserRoleInfo(principal);
        System.out.println("当前用户角色信息 = " + roles);
        //2.5.调用业务层获取用户的权限信息(数据库)
        List<String> permissions = userService.getUserPermissionInfo(roles);
        System.out.println("当前用户权限信息 = " + permissions);

        //3.创建对象,封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //存储角色
        info.addRoles(roles);
        //存储权限信息
        info.addStringPermissions(permissions);
        //4.返回信息
        return info;
    }

3.6.4.6.添加controller方法
    //登录认证验证权限
    @RequiresPermissions("user:delete")
    @GetMapping("userPermissions")
    @ResponseBody
    public String userLoginPermissions() {
        System.out.println("登录认证验证权限");
        return "验证权限成功";
    }
3.6.4.7.改造main.html
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
<br>
<a href="/logout">登出</a>
<br>
<a href="/myController/userLoginRoles">测试授权-角色验证</a>
<a href="/myController/userPermissions">测试授权-权限验证</a>
</body>
</html>
3.6.4.8.启动登录测试
http://localhost:8080/myController/userLogin

Shiro安全框架_第41张图片
Shiro安全框架_第42张图片

3.6.6.授权验证-异常处理

3.6.6.1.创建认证异常处理类,使用@ControllerAdvice 加@ExceptionHandler实现特殊异常处理。
//创建认证异常处理类,使用@ControllerAdvice 加@ExceptionHandler实现特殊异常处理
@ControllerAdvice
public class PermissionsException {

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

    @ResponseBody
    @ExceptionHandler(AuthorizationException.class)
    public String authorizationException(Exception e) {
        return "权限认证失败";
    }
}
3.6.6.2.启动测试,用李四登录测试

Shiro安全框架_第43张图片

http://localhost:8080/myController/userLogin

Shiro安全框架_第44张图片
Shiro安全框架_第45张图片

3.6.7.前端页面权限验证

3.6.7.1.添加依赖-配置Thymeleaf与Shiro的整合依赖
        <!--配置ThymeleafShiro的整合依赖-->
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>
3.6.7.2.配置类添加新配置–用于解析 thymeleaf中的 shiro:相关属性
	//用于解析 thymeleaf中的 shiro:相关属性
    @Bean
    public ShiroDialect shiroDialect() {
        return new ShiroDialect();
    }
3.6.7.3.Thymeleaf中常用的shiro:属性
需要在html页面中<html>添加属性
<html lang="en" xmlns:th="http://www.thymeleaf.org" 
xmlns:shiro="http://www.w3.org/1999/xhtml">

guest标签
  <shiro:guest>
  </shiro:guest>
  用户没有身份验证时显示相应信息,即游客访问信息。

user标签
  <shiro:user>  
  </shiro:user>
  用户已经身份验证/记住我登录后显示相应的信息。

authenticated标签
  <shiro:authenticated>  
  </shiro:authenticated>
  用户已经身份验证通过,即Subject.login登录成功,不是记住我登录的。

notAuthenticated标签
  <shiro:notAuthenticated>
  </shiro:notAuthenticated>
  用户已经身份验证通过,即没有调用Subject.login进行登录,包括记住我自动登录的也属于未进行身份验证。

principal标签
  <shiro: principal/>
  
  <shiro:principal property="username"/>
  相当于((User)Subject.getPrincipals()).getUsername()。

lacksPermission标签
  <shiro:lacksPermission name="org:create">
  </shiro:lacksPermission>
  如果当前Subject没有权限将显示body体内容。

hasRole标签
  <shiro:hasRole name="admin">  
  </shiro:hasRole>
  如果当前Subject有角色将显示body体内容。

hasAnyRoles标签
  <shiro:hasAnyRoles name="admin,user">
  </shiro:hasAnyRoles>
  如果当前Subject有任意一个角色(或的关系)将显示body体内容。

lacksRole标签
  <shiro:lacksRole name="abc">  
  </shiro:lacksRole>
  如果当前Subject没有角色将显示body体内容。

hasPermission标签
  <shiro:hasPermission name="user:create">  
  </shiro:hasPermission>
  如果当前Subject有权限将显示body体内容
3.6.7.4.改造main.html
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
<br>
<a href="/logout">登出</a>
<br>
<!--是否有admin角色-->
<a shiro:hasRole="admin" href="/myController/userLoginRoles">测试授权-角色验证</a>
<!--有没有delete权限-->
<a shiro:hasPermission="user:delete" href="/myController/userPermissions">测试授权-权限验证</a>
</body>
</html>
3.6.7.5.测试
http://localhost:8080/myController/login

Shiro安全框架_第46张图片
Shiro安全框架_第47张图片

3.6.8.源码

Shiro安全框架_第48张图片

3.6.8.1.pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.orange</groupId>
    <artifactId>shiro_springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.2.1.RELEASE</version>
    </parent>

    <dependencies>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>1.9.0</version>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!--配置ThymeleafShiro的整合依赖-->
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>
    </dependencies>

</project>
3.6.8.2.application.yml
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.jdbc.Driver
    url: jdbc:mysql://192.168.229.141:3306/shirodb?characterEncoding=utf-8&&useSSL=false
    username: root
    password: 123456
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

# 指定登录页面路径
shiro:
  loginUrl: /myController/login
3.6.8.3.ShiroConfig.java
package com.orange.shiro.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.orange.shiro.realm.MyRealm;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authc.pam.AllSuccessfulStrategy;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;

@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //创建认证对象,并设置认证策略
        ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
        defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);

        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);

        //封装myRealm集合
        ArrayList<Realm> list = new ArrayList<>();
        list.add(myRealm);
        //list.add(myRealm2);

        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealms(list);
        //4.1设置
        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());
        //AES的秘钥一定要是16位秘钥
        //Caused by: java.security.InvalidKeyException: Invalid AES key length: 10 bytes
        //cookieRememberMeManager.setCipherKey("1234567890".getBytes());
        cookieRememberMeManager.setCipherKey("1234567890123456".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;
    }

    //用于解析 thymeleaf中的 shiro:相关属性
    @Bean
    public ShiroDialect shiroDialect() {
        return new ShiroDialect();
    }

}

3.6.8.4.User.java
package com.orange.shiro.entiy;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

3.6.8.5.UserMapper.java
package com.orange.shiro.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.orange.shiro.entiy.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@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);

    //前后分别添加了,这是因为SQL中使用了动态sql标签
    @Select({""
    })
    List<String> getUserPermissionInfoMapper(@Param("roles") List<String> roles);
}

3.6.8.6.UserService.java
package com.orange.shiro.service;

import com.orange.shiro.entiy.User;

import java.util.List;

public interface UserService {
    //用户登录
    User getUserInfoByName(String name);

    //根据用户查询角色信息
    List<String> getUserRoleInfo(String principal);

    //获取用户角色权限信息
    List<String> getUserPermissionInfo(List<String> roles);
}

3.6.8.7.UserServiceImpl.java
package com.orange.shiro.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.orange.shiro.entiy.User;
import com.orange.shiro.mapper.UserMapper;
import com.orange.shiro.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@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;
    }

    //根据用户查询角色信息
    @Override
    public List<String> getUserRoleInfo(String principal) {
        return userMapper.getUserRoleInfoMapper(principal);
    }

    //获取用户权限信息
    @Override
    public List<String> getUserPermissionInfo(List<String> roles) {
        return userMapper.getUserPermissionInfoMapper(roles);
    }
}

3.6.8.8.MyRealm.java
package com.orange.shiro.realm;

import com.orange.shiro.entiy.User;
import com.orange.shiro.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;


@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    //自定义授权方法:获取当前登录用户权限信息,返回给 Shiro用来进行授权对比
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取当前用户的身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roles = userService.getUserRoleInfo(principal);
        System.out.println("当前用户角色信息 = " + roles);
        //2.5.调用业务层获取用户的权限信息(数据库)
        List<String> permissions = userService.getUserPermissionInfo(roles);
        System.out.println("当前用户权限信息 = " + permissions);

        //3.创建对象,封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //存储角色
        info.addRoles(roles);
        //存储权限信息
        info.addStringPermissions(permissions);
        //4.返回信息
        return info;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        //2.调用应用层获取用户信息(数据库)
        //3.非空判断,将数据封装返回
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用应用层获取用户信息(数据库)
        User user = userService.getUserInfoByName(name);
        //3.非空判断,将数据封装返回
        if (user != null) {
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }

}

3.6.8.9.PermissionsException.java
package com.orange.shiro.controller;

import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.authz.UnauthorizedException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

//创建认证异常处理类,使用@ControllerAdvice 加@ExceptionHandler实现特殊异常处理
@ControllerAdvice
public class PermissionsException {

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

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

3.6.8.10.MyController.java
package com.orange.shiro.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;

@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";
    }

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

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

}

3.6.8.11.ShiroMD5.java
package com.orange.shiro.utils;

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

public class ShiroMD5 {
    public static void main(String[] args) {
        //密码明文
        String password = "123456";

        //使用MD5加密
        Md5Hash md5Hash = new Md5Hash(password);
        System.out.println("MD5加密 = " + md5Hash);

        ///带盐的md5加密,盐就是在密码明文后拼接新字符串,然后再进行加密
        Md5Hash md5Hash2 = new Md5Hash(password, "salt");
        System.out.println("带盐 MD5加密 = " + md5Hash2.toHex());

        //为了保证安全,避免被破解还可以多次迭代加密,保证数据安全
        Md5Hash md5Hash3 = new Md5Hash(password, "salt", 5);
        System.out.println("带盐 MD5 五次加密 = " + md5Hash3.toHex());

        //使用父类实现加密
        SimpleHash simpleHash = new SimpleHash("MD5", password, "salt", 5);
        System.out.println("父类 MD5 带盐五次加密 = " + simpleHash.toHex());

    }
}

3.6.8.12.login.html
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</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>
3.6.8.13.main.html
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>shiro登录认证后主页面</h1>
<br>
登录用户名:<span th:text="${session.user}"></span>
<br>
<a href="/logout">登出</a>
<br>
<!--是否有admin角色-->
<a shiro:hasRole="admin" href="/myController/userLoginRoles">测试授权-角色验证</a>
<!--有没有delete权限-->
<a shiro:hasPermission="user:delete" href="/myController/userPermissions">测试授权-权限验证</a>
</body>
</html>
3.6.8.14.数据库和表
CREATE DATABASE IF NOT EXISTS shirodb CHARACTER SET utf8mb4;

show databases;

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=1 DEFAULT CHARSET=utf8 COMMENT='用户表';

insert into user(name,pwd)values
('zhangsan','564aef3cf9967536bc104b4089c5e049'),
('lisi','564aef3cf9967536bc104b4089c5e049');

select * from user;
use shirodb;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色表';

insert into `role` (`name`,`desc`,`realname`)values
('admin','所有权限','管理员'),
('userMag','用户管理权限','用户管理');

select * from role;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色用户映射表';

insert into `role_user` (`uid`,`rid`) values
(1,1),
(1,2),
(2,2);

select * from role_user;
USE shirodb;

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=1 DEFAULT CHARSET=utf8 COMMENT='权限表';

insert into  `permissions` (`name`,`info`,`desc`) values
('删除用户','user:delete','删除用户'),
('新增用户','user:add','新增用户'),
('修改用户','user:edit','修改用户');

select * from permissions;

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=1 DEFAULT CHARSET=utf8 COMMENT='角色权限映射表';

insert into  `role_ps`(`rid`,`pid`)values
(1,1),
(1,2),
(1,3);

select * from role_ps;

3.7.实现缓存

3.7.1.缓存工具EhCache

EhCache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。可以和大部分Java项目无缝整合,例如:Hibernate中的缓存就是基于EhCache实现的。
EhCache支持内存和磁盘存储,默认存储在内存中,如内存不够时把缓存数据同步到磁盘中。EhCache支持基于Filter的Cache实现,也支持Gzip压缩算法。
EhCache直接在JVM虚拟机中缓存,速度快,效率高;
EhCache缺点是缓存共享麻烦,集群分布式应用使用不方便 。

3.7.2.EhCache搭建使用

3.7.2.1.创建模块

Shiro安全框架_第49张图片

3.7.2.2.添加依赖
    <dependencies>
    	<!--ehcache为jvm内置缓存-->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.10.6</version>
            <type>pom</type>
        </dependency>
    </dependencies>
3.7.2.3.添加配置文件ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <!--
       diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <!--磁盘的缓存位置-->
    <diskStore path="java.io.tmpdir/ehcache"/>
    <!--
       defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk:硬盘最大缓存个数。
      eternal:对象是否永久有效,一但设置了,timeout将不起作用。
      overflowToDisk:是否保存到磁盘,当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
      diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
      memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
      clearOnFlush:内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
      FIFO,first in first out,这个是大家最熟的,先进先出。
      LFULess Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
      LRULeast Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
    <!--默认缓存-->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
            <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!--helloworld缓存-->
    <cache
            name="HelloWorldCache"
            maxElementsInMemory="1000"
            eternal="false"
            timeToIdleSeconds="5"
            timeToLiveSeconds="5"
            overflowToDisk="false"
            memoryStoreEvictionPolicy="LRU"/>

</ehcache>
3.7.2.4.创建测试类,操作缓存
package com.orange.ehcache;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import java.io.InputStream;

public class TestEH {
    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", "zhangsan");
        //存入缓存
        cache.put(element);
        //从缓存中取出
        Element element1 = cache.get("name");
        System.out.println("缓存中数据 = " + element1.getObjectValue());
    }
}

Shiro安全框架_第50张图片

3.7.3.Shiro整合EhCache

Shiro官方提供了shiro-ehcache,实现了整合EhCache作为Shiro的缓存工具。可以缓存认证执行的Realm方法,减少对数据库的访问,提高认证效率

3.7.3.1.添加依赖
        <!--Shiro整合Ehcache-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.13.0</version>
        </dependency>
3.7.3.2.在resources下添加配置文件 ehcache/ehcache-shiro.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="ehcache" updateCheck="false">
    <!--
       diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <!--磁盘的缓存位置-->
    <diskStore path="java.io.tmpdir/ehcache"/>
    <!--
       defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk:硬盘最大缓存个数。
      eternal:对象是否永久有效,一但设置了,timeout将不起作用。
      overflowToDisk:是否保存到磁盘,当系统当机时

      以下属性是可选的:
      timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
      diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
      memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。

      clearOnFlush:内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
      缓存的3 种清空策略 :
      FIFO,first in first out,这个是大家最熟的,先进先出。
      LFULess Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
      LRULeast Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
    <!--默认缓存-->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="false">
    </defaultCache>

    <!--登录认证信息缓存:缓存用户角色权限-->
    <cache  name="loginRolePsCache"
            maxElementsInMemory="2000"
            eternal="false"
            timeToIdleSeconds="600"
            timeToLiveSeconds="0"
            overflowToDisk="false"
            statistics="true"/>
</ehcache>
3.7.3.3.修改配置类ShiroConfig
package com.orange.shiro.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.orange.shiro.realm.MyRealm;
import net.sf.ehcache.CacheManager;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authc.pam.AllSuccessfulStrategy;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.io.ResourceUtils;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

@Configuration
public class ShiroConfig {

    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
        //1.创建defaultWebSecurityManager 对象
        //2.创建加密对象,设置相关属性
        //3.将加密对象存储到myRealm中
        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        //5.返回

        //1.创建defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //创建认证对象,并设置认证策略
        ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
        defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);

        //2.创建加密对象,设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1 采用MD5加密
        matcher.setHashAlgorithmName("md5");
        //2.2 采用迭代加密的次数
        matcher.setHashIterations(5);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);

        //封装myRealm集合
        ArrayList<Realm> list = new ArrayList<>();
        list.add(myRealm);
        //list.add(myRealm2);

        //4.将myRealm对象存储到defaultWebSecurityManager 对象
        defaultWebSecurityManager.setRealms(list);
        //4.1设置RememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //4.2设置缓存管理器
        defaultWebSecurityManager.setCacheManager(getEhcacheManager());

        //5.返回
        return defaultWebSecurityManager;
    }

    //缓存管理器获取
    private EhCacheManager getEhcacheManager() {
        EhCacheManager ehCacheManager = new EhCacheManager();
        //获取编译目录下的资源的流对象
        InputStream is = null;
        try {
            is = ResourceUtils.getInputStreamForPath("classpath:ehcache/ehcache-shiro.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取 EhCache的缓存管理对象 net.sf.ehcache.CacheManager
        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());
        //AES的秘钥一定要是16位秘钥
        //Caused by: java.security.InvalidKeyException: Invalid AES key length: 10 bytes
        //cookieRememberMeManager.setCipherKey("1234567890".getBytes());
        cookieRememberMeManager.setCipherKey("1234567890123456".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;
    }

    //用于解析 thymeleaf中的 shiro:相关属性
    @Bean
    public ShiroDialect shiroDialect() {
        return new ShiroDialect();
    }

}

3.7.3.4.启动测试

Shiro安全框架_第51张图片
Shiro安全框架_第52张图片

Shiro安全框架_第53张图片

先清除日志,再点击角色认证、权限认证,查看日志,没有查询数据库

Shiro安全框架_第54张图片

3.8.会话管理

3.8.1.SessionManager

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

3.8.2.会话管理实现

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

  • DefaultSessionManager:用于JavaSE环境
  • ServletContainerSessionManager:用于web环境,直接使用Servlet容器的会话
  • DefaultWebSessionManager:用于web环境,自己维护会话(不使用Servlet容器的会话管理)
    Shiro安全框架_第55张图片

3.8.3.获得session方式

3.8.3.1.实现
Session session = SecurityUtils.getSubject().getSession();

session.setAttribute(“key”,”value”) 
3.8.3.2.说明
Controller中的request,在shiro过滤器中的doFilerInternal方法,被包装成ShiroHttpServletRequestSecurityManagerSessionManager会话管理器决定 session来源于ServletRequest还是由Shiro管理的会话。 

无论是通过request.getSession 或subject.getSession获取到session,操作session,两者都是等价的。 

endl

你可能感兴趣的:(springboot,spring)