Apache Shiro 安全框架

已于 2023-04-04 16:16:34 修改
阅读量1.1k 收藏 1
点赞数 4
文章标签： java 1024程序员节
于 2022-10-24 23:24:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51715424/article/details/127504678
版权

文章目录

目录

文章目录

前言

一、shiro 是什么

1、什么是Shiro

2、Shiro与Spring Security 的对比

Shiro：

Spring Security：

3、Shiro的功能模块

二、Shiro的内部结构

​编辑

三、应用程序使用Shiro

四、Shiro的入门

1、搭建基于ini的运行环境

2、用户认证

3、用户授权

 4、自定义Realm

5、认证与授权的执行流程分析

6、过滤器  权限拦截器

五、shiro在SpringBoot 中的使用

1、案例说明

1.1 整合Shiro

1.2 Shiro的配置

1.3  shiro中的过滤器  在 shiro 中配置

1.4 授权

六、Shiro中的会话管理

1、什么是shiro的会话管理

2、应用场景分析

3、Shiro结合redis的统一会话管理

3.1 步骤分析

3.2 构建环境

3.3 自定义shiro会话管理器

3.4 配置Shiro基于redis的会话管理

前言

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

一、shiro 是什么

1、什么是Shiro

Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
Apache Shiro 的首要目标是易于使用和理解。安全有时候是很复杂的，甚至是痛苦的，但它没有必要这样。框架应该尽可能掩盖复杂的地方，露出一个干净而直观的 API，来简化开发人员在使他们的应用程序安全上的努力。以下是你可以用 Apache Shiro 所做的事情：

  • 验证用户来核实他们的身份
  • 对用户执行访问控制，如：
  • 判断用户是否被分配了一个确定的安全角色
  • 判断用户是否被允许做某事
  • 在任何环境下使用 Session API，即使没有 Web 或 EJB 容器。
  • 在身份验证，访问控制期间或在会话的生命周期，对事件作出反应。
  • 聚集一个或多个用户安全数据的数据源，并作为一个单一的复合用户“视图”。
  • 启用单点登录（SSO）功能。
  • 为没有关联到登录的用户启用"Remember Me"服务

2、Shiro与Spring Security 的对比

Shiro：

Shiro较之 Spring Security，Shiro在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。

  1.  易于理解的 Java Security API；
  2. 简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
  3. 对角色的简单的签权（访问控制），支持细粒度的签权；
  4. 支持一级缓存，以提升应用程序的性能；
  5. 内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
  6. 异构客户端会话访问；
  7. 非常简单的加密 API；
  8. 不跟任何的框架或者容器捆绑，可以独立运行

Spring Security：

除了不能脱离Spring，shiro的功能它都有。而且Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。Spring Security的权限细粒度更高。

3、Shiro的功能模块

Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。这不就是我们想要的嘛，而且Shiro的API也是非常简单；其基本功能点如下图所示：

  • Authentication：身份认证/登录，验证用户是不是拥有相应的身份。
  • Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情。
  • Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的。
  • Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。
  • Web Support：Shiro 的 web 支持的 API 能够轻松地帮助保护 Web 应用程序。
  • Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率。
  • Concurrency：Apache Shiro 利用它的并发特性来支持多线程应用程序。
  • Testing：测试支持的存在来帮助你编写单元测试和集成测试，并确保你的能够如预期的一样安全。
  • "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
  • "Remember Me"：记住我。

二、Shiro的内部结构

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

三、应用程序使用Shiro

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

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

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

四、Shiro的入门

1、搭建基于ini的运行环境

创建工程导入shiro坐标

<?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>cn.xidida</groupId>
    <artifactId>shiro_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.3.2</version>
        </dependency>
<!--        测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.3</version>
        </dependency>
    </dependencies>


</project>

2、用户认证

认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，是通过subject的login方法完成用户认证工作的

（1）在resource目录下创建shiro的ini配置文件构造模拟数据（shiro_config.ini）

[users]
#模拟从数据库查询的用户
#数据格式 用户名=密码
zhangsan=123456
lisi=123456

（2）测试用户认证

package cn.xidida.shiro;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.junit.Test;
/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/6 23:04
 * @notes
 */
public class ShiroTest01 {
    /**
     * 测试用户认证
     *      认证：用户登录
     *
     *      1、根据配置文件创建 SecurityManagerFactory
     *      2、通过工厂获取 SecurityManager
     *      3、将 SecurityManager 绑定到当前运行环境
     *      4、从当前运行环境中构造 subject
     *      5、构造 shiro 登录的数据
     *      6、主体登录
     */

    @Test
    public void testLogin(){
        // 1、根据配置文件创建 SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro_config.ini");
        //  2、通过工厂获取 SecurityManager
        SecurityManager instance = factory.getInstance();
        // 3、将 SecurityManager 绑定到当前运行环境
        SecurityUtils.setSecurityManager(instance);
        // 4、从当前运行环境中构造 subject
        Subject subject = SecurityUtils.getSubject();
        // 5、构造 shiro 登录的数据
        String name = "zhangsan";// 模拟用户输入
        String pwd = "123456";// 模拟用户输入

        UsernamePasswordToken token = new UsernamePasswordToken(name,pwd);
        // 6、主题登录
        subject.login(token);
        // 7、验证是否登录成功
        System.out.println("用户是否登录成功="+subject.isAuthenticated());
        // 8、获取登陆成功的数据
        System.out.println(subject.getPrincipal());
    }
}

登陆成功：

 登陆失败：

3、用户授权

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


（1）在resource目录下创建shiro的ini配置文件构造模拟数据（shiro_config2.ini）

[users]
#模拟从数据库查询的用户
#数据格式 用户名=密码,角色1,角色2..
zhangsan=123456,role1,role2
lisi=654321,role2
[roles]
#模拟从数据库查询的角色和权限列表
#数据格式 角色名=权限1，权限2
role1=user:save,user:update
role2=user:update,user.delete
role3=user.find

（2）完成用户授权

package cn.xidida.shiro;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.junit.Before;
import org.junit.Test;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/6 23:04
 * @notes
 */
public class ShiroTest02 {
    private SecurityManager securityManager;

    @Before
    public void init(){
        // 1、根据配置文件创建 SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro_config2.ini");
        //  2、通过工厂获取 SecurityManager
        SecurityManager instance = factory.getInstance();
        // 3、将 SecurityManager 绑定到当前运行环境
        SecurityUtils.setSecurityManager(instance);

    }


    @Test
    public void testLogin(){
        // 4、从当前运行环境中构造 subject
        Subject subject = SecurityUtils.getSubject();
        // 5、构造 shiro 登录的数据
        String name = "zhangsan";// 模拟用户输入
        String pwd = "123456";// 模拟用户输入
        UsernamePasswordToken token = new UsernamePasswordToken(name,pwd);
        // 6、主题登录
        subject.login(token);
        // 7、验证是否登录成功
        System.out.println("用户是否登录成功="+subject.isAuthenticated());
        // 8、获取登陆成功的数据
        System.out.println(subject.getPrincipal());
        // 9、登陆成功后 就是授权
        // 授权：检验当前登录用户是否具有操作权限，是否具有某个角色 很多东西都可以从 subject 中获取
        System.out.println("判断当前用户是否具有角色："+subject.hasRole("role1"));
        System.out.println("判断当前用户是否具有某个权限："+subject.isPermitted("user.find"));
    }
}

 4、自定义Realm

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

（1）自定义Realm

package cn.xidida.shiro;

import org.apache.shiro.authc.*;
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 java.util.ArrayList;
import java.util.List;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/6 23:38
 * @notes 自定义的 realms 对象
 *      继承 realms 对象
 *          继承 AuthorizingRealm
 *              重写 doGetAuthorizationInfo   授权
 *                  获取用户的授权数据（用户的权限数据）
 *              重写 doGetAuthenticationInfo  认证
 *                  根据用户名密码进行登陆，将用户数据保存（安全数据）
 */
public class PermissionRealm  extends AuthorizingRealm {

    /**
     *  重写  setName方法
     *      自定义 realm 名称
     * @param name
     */
    public void setName(String name) {
        super.setName("permissionrealm");
    }

    /**
     * 授权
     *      目的：根据认证的数据获取到用户的权限信息
     *
     * @param principalCollection  包含了所有已入住的安全数据
     * @return AuthorizationInfo 授权数据
     * 1、获取到安全数据
     * 2、根据ID或者用户名查询用户
     * 3、查询用户的角色和权限信息
     * 4、构造返回
     */
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //     * 1、获取到安全数据
        String username = (String) principalCollection.getPrimaryPrincipal();
        //     * 2、根据ID或者用户名查询用户
        //     * 3、查询用户的角色和权限信息
        List<String> perms = new ArrayList<String>();
        perms.add("user.add");
        perms.add("user.delete");
        List<String> roles = new ArrayList<String>();
        roles.add("role1");
        roles.add("role1");
        //     * 4、构造返回
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        // 设置权限结合
        info.addStringPermissions(perms);
        // 设置角色集合
        info.addRoles(roles);
        return info;
    }

    /**
     *  认证
     *      认证主要目的是，比较用户名和密码是否和数据库中的一致
     *          一致：则就会将数据存入到shiro 进行保管
     *
     * @param authenticationToken  登陆构造的 token
     * @return
     * @throws AuthenticationException
     */
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1、构造uptoken
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //2、输入的用户名密码
        String username = token.getUsername();
        String pwd = new String(token.getPassword());
        //3、根据用户名查询数据库。
        //4、比较密码和数据库中的密码是否一致（密码可能需要加密）
        if ("123456".equals(pwd)){
            //5、如果成功，向shiro 存入安全数据
            // SimpleAuthenticationInfo(1:安全数据，2：密码；3：当前 realm 域名称)
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username,pwd,getName());
            return info;
        }else {
            //6、失败 抛出异常或 返回 null
            throw new RuntimeException("用户名或密码错误");
        }
    }
}

（2）配置shiro的ini配置文件（shiro_config3.ini）

[main]
#声明realm
permReam=cn.itcast.shiro.PermissionRealm
#注册realm到securityManager中
securityManager.realms=$permReam

（3）验证

package cn.xidida.shiro;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.junit.Before;
import org.junit.Test;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/6 23:04
 * @notes
 */
public class ShiroTest03 {
    private SecurityManager securityManager;

    @Before
    public void init(){
        // 1、根据配置文件创建 SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro_config3.ini");
        //  2、通过工厂获取 SecurityManager
        SecurityManager instance = factory.getInstance();
        // 3、将 SecurityManager 绑定到当前运行环境
        SecurityUtils.setSecurityManager(instance);

    }


    @Test
    public void testLogin(){
        // 4、从当前运行环境中构造 subject
        Subject subject = SecurityUtils.getSubject();
        // 5、构造 shiro 登录的数据
        String name = "zhangsan";// 模拟用户输入
        String pwd = "123456";// 模拟用户输入
        UsernamePasswordToken token = new UsernamePasswordToken(name,pwd);
        // 6、主题登录
        // 执行 login --》realm 域中的方法(cn.xidida.shiro.PermissionRealm)
        subject.login(token);
        // 7、验证是否登录成功
        System.out.println("用户是否登录成功="+subject.isAuthenticated());
        // 8、获取登陆成功的数据
        System.out.println(subject.getPrincipal());
        // 9、登陆成功后 就是授权
        // 授权：检验当前登录用户是否具有操作权限，是否具有某个角色
        // 授权； --》 realm 域中的授权方法 （cn.xidida.shiro.PermissionRealm）
        System.out.println("判断当前用户是否具有角色："+subject.hasRole("role1"));
        System.out.println("判断当前用户是否具有某个权限："+subject.isPermitted("user.add"));
    }
}

5、认证与授权的执行流程分析

（1）认证流程

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

 （2）授权流程

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

6、过滤器  权限拦截器

过滤器简称

对应的java类

anon

org.apache.shiro.web.filter.authc.AnonymousFilter

authc

org.apache.shiro.web.filter.authc.FormAuthenticationFilter

authcBasic

org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter

perms

org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter

port

org.apache.shiro.web.filter.authz.PortFilter

rest

org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter

roles

org.apache.shiro.web.filter.authz.RolesAuthorizationFilter

ssl

org.apache.shiro.web.filter.authz.SslFilter

user

org.apache.shiro.web.filter.authc.UserFilter

logout

org.apache.shiro.web.filter.authc.LogoutFilter

五、shiro在SpringBoot 中的使用

Apache Shiro是一个功能强大、灵活的，开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。越来越多的企业使用Shiro作为项目的安全框架，保证项目的平稳运行。


在之前的讲解中只是单独的使用shiro，方便学员对shiro有一个直观且清晰的认知，我们今天就来看一下shiro在springBoot工程中如何使用以及其他特性

1、案例说明

使用springBoot构建应用程序，整合shiro框架完成用户认证与授权

/*
 Source Server         : 127.0.0.1：3306
 Source Server Type    : MySQL
 Source Server Version : 50726
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_authority
-- ----------------------------
DROP TABLE IF EXISTS `sys_authority`;
CREATE TABLE `sys_authority`  (
  `id` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '权限表',
  `authority_name` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '权限名称',
  `authority_code` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '权限编码',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_authority
-- ----------------------------

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role`  (
  `id` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '角色id',
  `role_name` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色名称',
  `role_code` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '橘色编码',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_role
-- ----------------------------

-- ----------------------------
-- Table structure for sys_role_authority
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_authority`;
CREATE TABLE `sys_role_authority`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `sys_id` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色id',
  `sys_id2` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '权限表',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `FK_Reference_3`(`sys_id`) USING BTREE,
  INDEX `FK_Reference_4`(`sys_id2`) USING BTREE,
  CONSTRAINT `FK_Reference_3` FOREIGN KEY (`sys_id`) REFERENCES `sys_role` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `FK_Reference_4` FOREIGN KEY (`sys_id2`) REFERENCES `sys_authority` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_role_authority
-- ----------------------------

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
  `id` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户id',
  `user_name` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '用户名',
  `user_pwd` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '密码',
  `telephone` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '电话号码',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_user
-- ----------------------------

-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `sys_id` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '用户id',
  `sys_id2` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色id',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `FK_Reference_1`(`sys_id`) USING BTREE,
  INDEX `FK_Reference_2`(`sys_id2`) USING BTREE,
  CONSTRAINT `FK_Reference_1` FOREIGN KEY (`sys_id`) REFERENCES `sys_user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `FK_Reference_2` FOREIGN KEY (`sys_id2`) REFERENCES `sys_role` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_user_role
-- ----------------------------

SET FOREIGN_KEY_CHECKS = 1;

1.1 整合Shiro

spring和shiro的整合依赖

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

修改登录方法

 认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，shiro需要采集到用户登录数据使用subject的login方法进入realm完成认证工作。

	@RequestMapping(value="/login")
    public String login(String username,String password) {
        /**
         * 密码加密：
         *      shiro 提供了默认的密码加密  =》 Md5Hash
         *      Md5Hash():
         *          参数1：加密内容
         *          参数2：盐（加密混淆字符串）（密码+混淆字符串）==>一般是随机字符串，到时候会存入数据库中
         *          参数3：加密次数
         *
         */
        try {
            // 加密
            password = new Md5Hash(password, username, 3).toString();
            // 构造登录令牌
            UsernamePasswordToken token =  new UsernamePasswordToken(username,password);
            //1、获取subject
            Subject subject = SecurityUtils.getSubject();
            // 2、调用 subject 进行登陆
            subject.login(token);
            return "登录成功";
        }catch (Exception e){
            return "用户名或密码错误";
        }
    }

自定义realm



import cn.itcast.shiro.domain.Permission;
import cn.itcast.shiro.domain.Role;
import cn.itcast.shiro.domain.User;
import cn.itcast.shiro.service.UserService;
import org.apache.shiro.authc.*;
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.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/8 20:05
 * @notes shiro 中自定义 realm 域
 */
public class CustomReaml extends AuthorizingRealm {
    @Override
    public void setName(String name) {
        super.setName("customReaml");// 名称一般用类名，也可以自定义
    }

    // 进行数据库查询
    @Autowired
    private UserService userService;
    /**
     * 授权：
     *      操作时，判断用户是否具有相应的权限
     *          先认证 -- 安全数据
     *          在授权 -- 根据安全数据获取用户具有的所有操作权限
     *
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 1、获取已认证的用户数据
        User user = (User) principalCollection.getPrimaryPrincipal();// 获取安全数据
        // 2、根据用户数据获取用户的权限信息，（所有角色，所有权限）
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        Set<String> roles = new HashSet<>();
        Set<String> perms = new HashSet<>();
        for(Role role:user.getRoles()){
            roles.add(role.getName());// 暂时存储 role 的名称
            for (Permission permission : role.getPermissions()){
                perms.add(permission.getCode());
            }
        }
        info.setRoles(roles);
        info.setStringPermissions(perms);
        // 返回授权
        return info;
    }

    /**
     * 认证：
     *      参数：用户名密码
     *
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 1、获取用户名密码（token）
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        String username = token.getUsername();
        String password = new String( token.getPassword() );// token.getPassword() 返回的是一个 char数组

        // 2、根据用户名查询数据库
        User user = userService.findByName(username);

        // 3、判断用户是否存在或者密码是否一致
        if (user!=null && user.getPassword().equals(password)){
            // 4、如果一致返回安全数据
            // 构造方法：安全数据；密码，realm 域
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
            return info;
        }
        // 5、不一致，返回 null(抛出异常)
        return null;
    }
}

1.2 Shiro的配置

SecurityManager 是 Shiro 架构的心脏，用于协调内部的多个组件完成全部认证授权的过程。例如通过调用realm完成认证与登录。使用基于springboot的配置方式完成SecurityManager，Realm的装配

无redis 配置：

package cn.itcast.shiro;

import cn.itcast.shiro.reaml.CustomReaml;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/8 20:34
 * @notes shiro 配置
 */

@Configuration
public class ShiroConfig {
    // 1、创建 realm
    @Bean
    public CustomReaml getRealm(){
        return new CustomReaml(); //CustomReaml ==》自定义 customReaml
    }
    // 2、创建安全管理器
    @Bean
    public SecurityManager securityManager(CustomReaml reaml){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(reaml);
        return securityManager;
    }
    // 3、配置 shiro 的过滤器工厂

    /**
     *  在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        // 1、创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        // 2、设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        // 3、通过配置（跳转登陆页面，为授权跳转的页面）
        filterFactory.setLoginUrl("/longinerror");// 跳转到url  路径 （没有登陆跳转）
        filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
        // 4、设置过滤器集合
        /**
         * 设置所有的过滤器：map
         *      key=拦截的 url 地址
         *      value=过滤器类型
         *      可以选择有序的 map 集合==》LinkedHashMap
         */
        Map<String,String> filterMap = new LinkedHashMap<>();
        //当前请求地址可以匿名访问
        filterMap.put("/user/home","anon");
        // swagger 访问地址开放地址
        filterMap.put("/doc.htm**","anon");
        filterMap.put("/webjars/**","anon");
        filterMap.put("/swagger**","anon");
        filterMap.put("/v2/**","anon");
        // 登陆接口
        filterMap.put("/login","anon");

        // 当前请求地址必须认证之后才可以访问
        filterMap.put("/**","authc");
        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }

    // 4、开启shiro 注解的支持
    //配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

}

redis配置

import cn.itcast.shiro.realm.CustomRealm;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.web.servlet.Cookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class ShiroConfiguration {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    //配置自定义的Realm
    @Bean
    public CustomRealm getRealm() {
        return new CustomRealm();
    }

    //配置安全管理器
    @Bean
    public SecurityManager securityManager(CustomRealm realm) {
        //使用默认的安全管理器
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(realm);
        // 自定义session管理 使用redis
        securityManager.setSessionManager(sessionManager());
        // 自定义缓存实现 使用redis
        securityManager.setCacheManager(cacheManager());
        //将自定义的realm交给安全管理器统一调度管理
        securityManager.setRealm(realm);
        return securityManager;
    }

    //Filter工厂，设置对应的过滤条件和跳转条件
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        //1.创建shiro过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        //2.设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        //3.通用配置（配置登录页面，登录成功页面，验证未成功页面）
        filterFactory.setLoginUrl("/autherror?code=1"); //设置登录页面
        filterFactory.setUnauthorizedUrl("/autherror?code=2"); //授权失败跳转页面
        //4.配置过滤器集合
        /**
         * key  ：访问连接
         *      支持通配符的形式
         * value：过滤器类型
         *      shiro常用过滤器
         *          anno    ：匿名访问（表明此链接所有人可以访问）
         *          authc   ：认证后访问（表明此链接需登录认证成功之后可以访问）
         */
        Map<String,String> filterMap = new LinkedHashMap<String,String>();
        //配置请求连接过滤器配置
        //匿名访问（所有人员可以使用）
        filterMap.put("/user/home", "anon");
        //具有指定权限访问
        //filterMap.put("/user/find", "perms[user-find]");
        //认证之后访问（登录之后可以访问）
        filterMap.put("/user/**", "authc");
        //具有指定角色可以访问
        filterMap.put("/user/**", "roles[系统管理员]");


        //5.设置过滤器
        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }

    //配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

    //配置shiro redisManager
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        return redisManager;
    }

    //cacheManager缓存 redis实现
    public RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

    /**
     * RedisSessionDAO shiro sessionDao层的实现 通过redis
     * 使用的是shiro-redis开源插件
     */
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * shiro session的管理
     */
    public DefaultWebSessionManager sessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionDAO(redisSessionDAO());
        Cookie cookie =  sessionManager.getSessionIdCookie();
        cookie.setName("my_sid"); //声明cooike中session的名称
        sessionManager.setSessionIdCookie(cookie);
        return sessionManager;
    }
}

1.3  shiro中的过滤器  在 shiro 中配置

注意：anon, authc, authcBasic, user 是第一组认证过滤器，perms, port, rest, roles, ssl 是第二组授权过滤器，要通过授权过滤器，就先要完成登陆认证操作（即先要完成认证才能前去寻找授权) 才能走第二组授权器（例如访问需要 roles 权限的 url，如果还没有登陆的话，会直接跳转到shiroFilterFactoryBean.setLoginUrl(); 设置的 url ） 

1.4 授权

基于配置的授权

授权：即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情
shiro支持基于过滤器的授权方式也支持注解的授权方式

在shiro中可以使用过滤器的方式配置目标地址的请求权限

import cn.itcast.shiro.reaml.CustomReaml;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/8 20:34
 * @notes shiro 配置
 */

@Configuration
public class ShiroConfig {
    // 1、创建 realm
    @Bean
    public CustomReaml getRealm(){
        return new CustomReaml(); //CustomReaml ==》自定义 customReaml
    }
    // 2、创建安全管理器
    @Bean
    public SecurityManager securityManager(CustomReaml reaml){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(reaml);
        return securityManager;
    }
    // 3、配置 shiro 的过滤器工厂

    /**
     *  在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        // 1、创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        // 2、设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        // 3、通过配置（跳转登陆页面，为授权跳转的页面）
        filterFactory.setLoginUrl("/longinerror");// 跳转到url  路径 （没有登陆跳转）
        filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
        // 4、设置过滤器集合
        /**
         * 设置所有的过滤器：map
         *      key=拦截的 url 地址
         *      value=过滤器类型
         *      可以选择有序的 map 集合==》LinkedHashMap
         */
        Map<String,String> filterMap = new LinkedHashMap<>();


        // 不需要登录 即可访问
        //当前请求地址可以匿名访问
        filterMap.put("/user/home","anon");
        // 当前请求地址可以匿名访问  swagger 访问地址开放地址
        filterMap.put("/doc.htm**","anon");
        filterMap.put("/webjars/**","anon");
        filterMap.put("/swagger**","anon");
        filterMap.put("/v2/**","anon");
        // 登陆接口
        filterMap.put("/login","anon");


        // 当前请求地址必须认证之后才可以访问  需要登录才能访问
        filterMap.put("/user**","authc");
        filterMap.put("/test","authc");

        // 使用 过滤器 的形式来配置 权限
        // 需要当前用户 拥有 该角色  才能访问  role.getName()  在 realm 中的授权存入内容的
        filterMap.put("/user/list","roles[系统管理员]");

        // 需要有权限才能访问
        // 具有 某种权限才能访问 查询用户 当有 user-find 该权限才能访问该接口
        // 也可以使用 注解的形式来配置 权限  user-find ==》为 permission.getCode() 在 realm 中的授权存入内容的
        filterMap.put("/user/list","perms[user-find]");// 如果不具有这个权限则就跳转到 setUnauthorizedUrl 改接口



        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }

    // 4、开启shiro 注解的支持
    //配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

}

基于注解的授权

/**
 * import org.apache.shiro.authz.annotation.RequiresRoles;
 * import org.apache.shiro.authz.annotation.RequiresPermissions;
 * 使用 shiro 注解的形式实现  角色  及其 权限 授权
 *  @RequiresPermissions() ：访问当前方法必须具备的权限
 *  @RequiresRoles()   ： 访问当前方法所具备的角色
 * @return
 * 1、过滤器：如果权限信息不匹配 则会运行改方法 setUnauthorizedUrl("/autherror");
 * 2、注解：如果没有权限则会 抛出异常 ：AuthorizationException
 * @RequiresPermissions("user-list")
 * @RequiresRoles("系统管理员")
 */

 配置

package cn.itcast.shiro;

import cn.itcast.shiro.reaml.CustomReaml;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/8 20:34
 * @notes shiro 配置
 */

@Configuration
public class ShiroConfig {
    // 1、创建 realm
    @Bean
    public CustomReaml getRealm(){
        return new CustomReaml(); //CustomReaml ==》自定义 customReaml
    }
    // 2、创建安全管理器
    @Bean
    public SecurityManager securityManager(CustomReaml reaml){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(reaml);
        return securityManager;
    }
    // 3、配置 shiro 的过滤器工厂

    /**
     *  在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        // 1、创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        // 2、设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        // 3、通过配置（跳转登陆页面，为授权跳转的页面）
        filterFactory.setLoginUrl("/longinerror");// 跳转到url  路径 （没有登陆跳转）
        filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
        // 4、设置过滤器集合
        /**
         * 设置所有的过滤器：map
         *      key=拦截的 url 地址
         *      value=过滤器类型
         *      可以选择有序的 map 集合==》LinkedHashMap
         */
        Map<String,String> filterMap = new LinkedHashMap<>();


        // 不需要登录 即可访问
        //当前请求地址可以匿名访问
        filterMap.put("/user/home","anon");
        // 当前请求地址可以匿名访问  swagger 访问地址开放地址
        filterMap.put("/doc.htm**","anon");
        filterMap.put("/webjars/**","anon");
        filterMap.put("/swagger**","anon");
        filterMap.put("/v2/**","anon");
        // 登陆接口
        filterMap.put("/login","anon");


        // 当前请求地址必须认证之后才可以访问  需要登录才能访问
        filterMap.put("/user**","authc");
        filterMap.put("/test","authc");

        // 使用 过滤器 的形式来配置 权限
        // 需要当前用户 拥有 该角色  才能访问  role.getName()  在 realm 中的授权存入内容的
//        filterMap.put("/user/list","roles[系统管理员]");

        // 需要有权限才能访问
        // 具有 某种权限才能访问 查询用户 当有 user-find 该权限才能访问该接口
        // 也可以使用 注解的形式来配置 权限  user-find ==》为 permission.getCode() 在 realm 中的授权存入内容的
//        filterMap.put("/user/list","perms[user-list]");// 如果不具有这个权限则就跳转到 setUnauthorizedUrl 改接口



        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }

    // 4、开启shiro 注解的支持
    //配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

}

controller

  /**
     * import org.apache.shiro.authz.annotation.RequiresRoles;
     * import org.apache.shiro.authz.annotation.RequiresPermissions;
     * 使用 shiro 注解的形式实现  角色  及其 权限 授权
     *  @RequiresPermissions() ：访问当前方法必须具备的权限
     *  @RequiresRoles()   ： 访问当前方法所具备的角色
     * @return
     * 1、过滤器：如果权限信息不匹配 则会运行改方法 setUnauthorizedUrl("/autherror");
     * 2、注解：如果没有权限则会 抛出异常 ：AuthorizationException
     * @RequiresPermissions("user-list")
     * @RequiresRoles("系统管理员")
     */
    @RequiresPermissions("user-list")
//    @RequiresRoles()
    @ApiOperation("查询用户")
    @RequestMapping(value = "/user/list",method = RequestMethod.GET)
    public String find() {
        return "查询用户成功";
    }

异常处理



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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 注解 配置权限实现内容
 * 自定义的公共异常处理器
 *      1.声明异常处理器
 *      2.对异常统一处理
 * AuthorizationException
 */
@ControllerAdvice
public class BaseExceptionHandler {
    // 监听 异常抛出名称 AuthorizationException 的异常抛出
    @ExceptionHandler(value = AuthorizationException.class)
    @ResponseBody
    public String error(HttpServletRequest request, HttpServletResponse response,AuthorizationException e) {
		return "未授权";
    }
}

六、Shiro中的会话管理

在shiro里所有的用户的会话信息都会由Shiro来进行控制，shiro提供的会话可以用于JavaSE/JavaEE环境，不依赖于任何底层容器，可以独立使用，是完整的会话模块。通过Shiro的会话管理器（SessionManager）进行统一的会话管理

1、什么是shiro的会话管理

SessionManager（会话管理器）：管理所有Subject的session包括创建、维护、删除、失效、验证等工作。SessionManager是顶层组件，由SecurityManager管理shiro提供了三个默认实现：

  1. DefaultSessionManager：用于JavaSE环境
  2. ServletContainerSessionManager：用于Web环境，直接使用servlet容器的会话。
  3. DefaultWebSessionManager：用于web环境，自己维护会话（自己维护着会话，直接废弃了Servlet容器的会话管理）。

在web程序中，通过shiro的Subject.login()方法登录成功后，用户的认证信息实际上是保存在HttpSession中的通过如下代码验证。

//登录成功后，打印所有session内容
    @ApiOperation("查看session中存储的shiro信息")
    @RequestMapping(value="/show",method = RequestMethod.GET)
    public String show(HttpSession session) {
        // 获取session中所有的键值
        Enumeration<?> enumeration = session.getAttributeNames();
        // 遍历enumeration中的
        while (enumeration.hasMoreElements()) {
            // 获取session键值
            String name = enumeration.nextElement().toString();
            // 根据键值取session中的值
            Object value = session.getAttribute(name);
            // 打印结果
            System.out.println("<B>" + name + "</B>=" + value + "<br>/n");
        }
        return "查看session成功";
    }

2、应用场景分析

在分布式系统或者微服务架构下，都是通过统一的认证中心进行用户认证。如果使用默认会话管理，用户信息只会保存到一台服务器上。那么其他服务就需要进行会话的同步。

会话管理器可以指定sessionId的生成以及获取方式。
通过sessionDao完成模拟session存入，取出等操作 

3、Shiro结合redis的统一会话管理

3.1 步骤分析

3.2 构建环境

3.2.1 构建环境

（1）使用开源组件Shiro-Redis可以方便的构建shiro与redis的整合工程

<dependency>
    <groupId>org.crazycake</groupId>
        <artifactId>shiro-redis</artifactId>
    <version>3.0.0</version>
</dependency>

（2） 在springboot配置文件中添加redis配置

spring:
  redis:
    host: 127.0.0.1
    port: 6380
    password: 123456

3.3 自定义shiro会话管理器


import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/12 22:58
 * @notes  自定义 Manager
 */
public class CustomSessionManager  extends DefaultWebSessionManager {
    /**
     * 头信息中具有sessionId
     *      请求头：Authorization:  sessionid
     *
     *
     * 指定sessionId的一个方法
     */
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        //获取请求头中的信息
        String sessionId = WebUtils.toHttp(request).getHeader("Authorization");
        if (StringUtils.isEmpty(sessionId)){
            // 如果没有携带，生成新的session
            return super.getSessionId(request,response);
        }else {
            // 返回 sessionId
            // 将 sessionId 放到请求头中
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
            // 当前 sessionid 具体是什么
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, sessionId);
            //该sessionId是否需要验证
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);

            return sessionId;
        }
    }
}

3.4 配置Shiro基于redis的会话管理

在Shiro配置类 cn.itcast.shiro.ShiroConfiguration 配置
1. 配置shiro的RedisManager，通过shiro-redis包提供的RedisManager统一对redis操作

    // 获取redis 配置
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;

    /**
     *1、redis 配置 控制器
     */
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setPort(port);
        redisManager.setHost(host);
        redisManager.setPassword(password);
        return redisManager;
    }

2. Shiro内部有自己的本地缓存机制，为了更加统一方便管理，全部替换redis实现


    /**
     * 4、Redis 缓存管理器
     * @return
     */
    public RedisCacheManager cacheManager(){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

3. 配置SessionDao，使用shiro-redis实现的基于redis的sessionDao

    /**
     * 2、redis SessionDao
     * @return
     */
    public RedisSessionDAO redisSessionDAO(){
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

4. 配置会话管理器，指定sessionDao的依赖关系

    /**
     * 3、redis 配置自定义会话管理器
     * @return
     */
    public DefaultWebSessionManager sessionManager(){
        CustomSessionManager customSessionManager = new CustomSessionManager();
        customSessionManager.setSessionDAO(redisSessionDAO());
        return customSessionManager;
    }

5. 统一交给SecurityManager管理

  // 2、创建安全管理器
    @Bean
    public SecurityManager securityManager(CustomReaml reaml){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(reaml);

        //redis 将自定义的会话管理器注册到安全管理器中
        securityManager.setSessionManager(sessionManager());
        // redis 将自定义的 redis 缓存管理器注册到安全管理器中
        securityManager.setCacheManager(cacheManager());

        return securityManager;
    }

总配置

package cn.itcast.shiro;

import cn.itcast.shiro.reaml.CustomReaml;

import cn.itcast.shiro.session.CustomSessionManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;

/**
 * @author YJC
 * @e-mail xiaochun235@qq.com
 * @Date 2022/12/8 20:34
 * @notes shiro 配置
 */

@Configuration
public class ShiroConfig {
    // 1、创建 realm
    @Bean
    public CustomReaml getRealm(){
        return new CustomReaml(); //CustomReaml ==》自定义 customReaml
    }
    // 2、创建安全管理器
    @Bean
    public SecurityManager securityManager(CustomReaml reaml){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(reaml);

        //redis 将自定义的会话管理器注册到安全管理器中
        securityManager.setSessionManager(sessionManager());
        // redis 将自定义的 redis 缓存管理器注册到安全管理器中
        securityManager.setCacheManager(cacheManager());

        return securityManager;
    }
    // 3、配置 shiro 的过滤器工厂

    /**
     *  在 web 程序中，shiro 进行权限控制全部是通过一组过滤器集合进行控制
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        // 1、创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        // 2、设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        // 3、通过配置（跳转登陆页面，为授权跳转的页面）
        filterFactory.setLoginUrl("/longinerror");// 跳转到url  路径 （没有登陆跳转）
        filterFactory.setUnauthorizedUrl("/autherror");//未授权的页面 （没有权限跳转）
        // 4、设置过滤器集合
        /**
         * 设置所有的过滤器：map
         *      key=拦截的 url 地址
         *      value=过滤器类型
         *      可以选择有序的 map 集合==》LinkedHashMap
         */
        Map<String,String> filterMap = new LinkedHashMap<>();


        // 不需要登录 即可访问
        //当前请求地址可以匿名访问
        filterMap.put("/user/home","anon");
        // 当前请求地址可以匿名访问  swagger 访问地址开放地址
        filterMap.put("/doc.htm**","anon");
        filterMap.put("/webjars/**","anon");
        filterMap.put("/swagger**","anon");
        filterMap.put("/v2/**","anon");
        // 登陆接口
        filterMap.put("/login","anon");


        // 当前请求地址必须认证之后才可以访问  需要登录才能访问
        filterMap.put("/user**","authc");
        filterMap.put("/test","authc");

        // 使用 过滤器 的形式来配置 权限
        // 需要当前用户 拥有 该角色  才能访问  role.getName()  在 realm 中的授权存入内容的
//        filterMap.put("/user/list","roles[系统管理员]");

        // 需要有权限才能访问
        // 具有 某种权限才能访问 查询用户 当有 user-find 该权限才能访问该接口
        // 也可以使用 注解的形式来配置 权限  user-find ==》为 permission.getCode() 在 realm 中的授权存入内容的
//        filterMap.put("/user/list","perms[user-list]");// 如果不具有这个权限则就跳转到 setUnauthorizedUrl 改接口



        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }
    // 获取redis 配置
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;

    /**
     *1、redis 配置 控制器
     */
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setPort(port);
        redisManager.setHost(host);
        redisManager.setPassword(password);
        return redisManager;
    }
    /**
     * 2、redis SessionDao
     * @return
     */
    public RedisSessionDAO redisSessionDAO(){
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * 3、redis 配置自定义会话管理器
     * @return
     */
    public DefaultWebSessionManager sessionManager(){
        CustomSessionManager customSessionManager = new CustomSessionManager();
        customSessionManager.setSessionDAO(redisSessionDAO());
         // 禁用 cookie (可写)
        customSessionManager.setSessionIdCookieEnabled(false);
        // 禁用 url 重写 url;jsessionid=id (可写)
        customSessionManager.setSessionIdUrlRewritingEnabled(false);
        return customSessionManager;
    }

    /**
     * 4、Redis 缓存管理器
     * @return
     */
    public RedisCacheManager cacheManager(){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }


    // 4、开启shiro 注解的支持
    //配置shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

}

 /**

 * 重写 AuthCachePrincipal 方法
 * @return
 */
@Override
public String getAuthCacheKey() {
    return null;
}

验证：

严不纯
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
apache shiro maven包
12-03
Shiro 是一个 Apache Incubator 项目，旨在简化身份验证和授权。在本文中，了解 Apache Shiro 并通过示例来在一个 Groovy web 应用程序中尝试使用 Shiro 进行身份验证和授权
Shiro安全框架详解及springboot使用示例
weixin_46822367的博客
12-28 2794
目录一、认识Shiro1、什么是Shiro？2、有哪些功能？3、Shiro架构（外部）4、Shiro架构（内部） 一、认识Shiro 1、什么是Shiro？ Apache Shiro 是一个Java 的安全（权限）框架。 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环 境。 Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。 2、有哪些功能？ Authentication：身份认证、登录，验证用户是不是拥有相应的身份； Aut
【Shiro安全框架】核心概念、基本配置、整合Web项目
m0_74187147的博客
04-21 1158
问题1：什么是shiro?它有什么用？​ 答：shiro是apache公司推出的一款安全框架，主要在项目中进行权限控制。 shiro中的几个核心概念： 1、SecurityManager:安全管理器 作用：用于执行认证（登录）、授权（获得用户的访问权限） 2、Subject:主体 作用：它代表当前用户 3、Realm:领域对象 作用：它用于封装认证、授权的方法
什么是 Apache Shiro
web15085599741的博客
03-29 5722
什么是Apache Shiro Apache Shiro 是一种功能强大且易于使用的Java安全框架，它具有身份验证、访问授权、数据加密、会话管理等功能，可用于保护任何应用程序的安全。 如: 命令行应用程序、移动应用程序、Web应用程序、企业级应用程序。从小到大到很大，Apache Shiro都会给你提供安全帮助。 Shiro 为你的应用程序提供如下API,帮助你更好的管理应用程序的安全。 身份验证 证明用户的身份。也就是所谓的用户的 “登录” 功能，验证访问的用户是否有权利登录系统或者访问后台接口。
Apache Shiro 简介
web15085599741的博客
04-29 1158
Apache Shiro简介 什么是 Apache Shiro Apache Shiro 是一个强大并且灵活的开源的安全框架，它能很好的处理 authentication（认证）, authorization(授权), enterprise session management（企业会话管理）和cryptography（密码加密）。 Apache Shiro最重要的目标就是易于使用和理解。安全有时候会非常的复杂，甚至是痛苦的，但是它并不一定如此的。一个框架屏蔽复杂性， 如有可能暴露一个干净，直观的API，简
Apache Shiro流量特征及漏洞利用
qq_53218512的博客
06-02 1281
Apache Shiro是一个强大易用的Java安全框架，提供了认证、授权和会话管理等功能。Shiro框架直观、易用，同时也能提供更健壮的安全性。
Apache Shiro(一）
qq_42847719的博客
01-01 1198
如同上面提到的，Realm 是 shiro 和你的应用程序安全数据之间的“桥”或“连接”，当实际要与安全相关的数据进行交互如用户执行身份认证（登录）和授权验证（访问控制）时，shiro 从程序配置的一个或多个Realm 中查找这些数据，你需要配置多少个 Realm 便可配置多少个 Realm（通常一个数据源一个），shiro 将会在认证和授权中协调它们。是不是需要所有方面的验证都成功？简单就是不同的角色用户只能访问指定的信息 ，我们需要知道用户有那些角色，用户有那些权限 ，包结构和之前的一致3-3。
基于Java的Apache Shiro安全框架设计源码
最新发布
06-01
本源码是基于Java开发的Apache Shiro安全框架设计，包含1040个文件，其中包括724个.java文件，92个.groovy文件，72个.xml文件，36个.jsp文件，以及23个.properties文件，16个.ini文件，10个.md文件，7个.css文件和5...
Apache Shiro安全框架-其他
06-12
Apache Shiro（发音为“shee-roh”，日语为“castle”）是一种功能强大且易于使用的Java安全框架，可执行身份验证，授权，加密和会话管理，可用于保护任何应用程序的安全-从命令行应用程序，移动应用程序到最大的Web...
Apache Shiro安全框架 v1.8.0.zip
03-18
Apache Shiro安全框架 v1.8.0.zip
Apache Shiro安全框架深入讲解+面试题+案例
06-10
内容包括权限管理原理和表结构设计，基于文本域的身份验证和权限验证，基于JDBC域的身份验证和权限验证，盐和加密，集成web环境，shiro过滤器的使用，session的管理，缓存和SSM的集成等。边讲边记，绝不照搬照念，是...
Apache Shiro 框架简介
01-11
Apache Shiro是一个强大易用的Java安全框架，提供了认证、授权、加密和会话管理等功能：  认证 – 用户身份识别，常被称为用户“登录”； 授权 – 访问控制； 密码加密 – 保护或隐藏数据防止被偷窥； ...
Apache Shiro教程（1）
醉代码的博客
01-09 525
*** 配置一个 SecurityManager安全管理器* @return} /*** 配置过滤器* 例如 什么可以进行访问，什么不可以进行访问等等* @return//配置用户登陆请求，如果需要进行登陆时， // shiro就会进入这个请求进入登陆页面 shiroFilterFactoryBean . setSecurityManager(securityManager);
Apache Shiro，这一篇就够了
大河之犬的博客
12-18 781
点击后会跳转到一个login.jsp页面，这个不是我们想要的效果，我们需要自己定义一个login页面！然后在 shiroFilterFactoryBean 中配置一个未授权的请求页面！我们再次启动测试一下，访问add，发现以下错误！在UserRealm 中添加授权的逻辑，增加授权的字符串！改造UserRealm，连接到数据库进行真实的操作！再次测试，成功的跳转到了我们指定的Login页面！编写实体类：（和数据库中的表字段要对应哦）使用shiro的过滤器来拦截请求即可！在前端修改对应的信息输出或者请求！
Shiro权限控制+整合shiro
热门推荐
Armymans的博客
03-02 1万+
Shiro权限控制 0.1传统的权限认证方式 特点：为每个人单独的分配权限模块，能够实现权限控制，但是当公司人员庞大之后，非常难管理 上述权限控制如何设计表？ 关系：员工和菜单权限的关系：多对多 员工id 菜单名称 1 取派管理 2 快递员管理 2 运单管理 好处：可以方便的 实现权限控制 缺陷：比如当修改权限的时候，公司统一的给组长级别的人 加一个“计算工资”权限，...
1.Apache Shiro（认证，授权）基本介绍
相互学习 共同进步
06-15 2270
Apache Shiro（认证，授权）基本介绍 什么是Apache Shiro？ Apache Shiro是一个功能强大且灵活的开源安全框架，可以干净地处理身份验证、授权、企业会话管理和加密，提供了一种直观，全面的身份验证、授权、加密和会话管理解决方案 Apache Shiro的首要目标是易于使用、理解。安全有时可能非常复杂，甚至会很痛苦，但这不是必须的。框架应尽可能掩盖复杂性，并公开简洁直观的API，以简化开发人员确保其应用程序安全的工作 官网：http://shiro.apache.org/ 同类的比
Apache Shiro 安全框架700字
04-23
Apache Shiro是一个开源的安全框架，主要用于Java应用程序的安全管理。它提供了一套细粒度的安全授权和认证机制，可帮助开发人员简化应用程序的安全管理，并提高应用程序的安全性。 Apache Shiro采用了标准的JavaEE-Security API，并提供了自己的API，可以无缝集成到常见的Web应用程序中。 Apache Shiro的主要功能包括： 1. 身份认证：验证用户的身份，确保用户是合法用户。 2. 访问控制：控制用户对系统资源的访问权限，确保用户只能访问他们被授权的资源。 3. 密码加密：对用户的密码进行加密，确保用户的密码不被恶意攻击者窃取。 4. 会话管理：管理用户的会话，确保用户的会话不被恶意攻击者窃取或篡改。 Apache Shiro的优点包括： 1. 简单易用：相比其他安全框架，Apache Shiro的设计非常简单，API易于理解和使用。 2. 灵活性高：Apache Shiro可以与其他框架和技术无缝集成，可以应用于各种类型的应用程序。 3. 安全性高：Apache Shiro提供了一套完整的安全管理机制，可以有效地保护应用程序不受攻击。 4. 社区活跃：Apache Shiro的社区非常活跃，有更新快速和版本稳定的特点。 总之，Apache Shiro是一款优秀的安全框架，提供了一整套安全管理机制，可以帮助开发人员更轻松地管理应用程序的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值