Spring Boot与Shiro实现权限管理02

已于 2022-11-06 23:37:23 修改
阅读量718 收藏 1
点赞数 1
分类专栏： SpringBoot 文章标签： spring boot 数据库 java
于 2022-11-06 22:20:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pikcacho_pkq/article/details/127711893
版权

1.前期设计

1.1 功能模块的设计

用户权限管理系统一般包括以下模块：
在这里插入图片描述

1.2 数据库的设计

根据基本的功能可以总结出6张数据库表：

  • sys_permission：权限表
  • sys_role：角色表
  • sys_role_permission：角色-权限关联表
  • sys_user：用户表
  • sys_user_role：用户角色关联表
  • notify：通知表

接下来就是创建数据库acs和表的具体设计了。

1.sys_permission：
CREATE TABLE `sys_permission`
(
    `id`              int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time`     timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time`     timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `permission_code` varchar(255)    NOT NULL COMMENT '权限的代码/通配符',
    `permission_name` varchar(255)    NOT NULL COMMENT '权限的中文释义',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_permission_code` (`permission_code`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='权限表';

权限表用于将系统中所有支持进行权限控制的资源及其相关操作进行声明。

WildcardPermission 是 Shiro Permission 接口的一个实现，它允许我们将权限表示为通配符的方式，通配符字符串能作为方法参数传递给 Subject.isPermitted 以完成权限检查。例如：

  • “notify:edit”：表示 “编辑通知” 权限。
  • “notify:*”：表示对通知的任何操作。

接下来需要将系统中所有的权限都定义好，然后插入到数据库中。

INSERT INTO `sys_permission`(id, permission_code, permission_name)
VALUES (101, 'notify:list', '通知列表'),
       (102, 'notify:add', '创建通知'),
       (103, 'notify:edit', '编辑通知'),
       (104, 'notify:delete', '删除通知'),

       (301, 'user:list', '用户列表'),
       (302, 'user:add', '新增用户'),
       (303, 'user:edit', '编辑用户'),
       (304, 'user:delete', '删除用户'),

       (501, 'role:list', '角色列表'),
       (502, 'role:add', '新增角色'),
       (503, 'role:edit', '编辑角色'),
       (504, 'role:delete', '删除角色');
2.sys_role：
CREATE TABLE `sys_role`
(
    `id`          int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `role_name`   varchar(20)     NOT NULL COMMENT '角色名',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_role_name` (`role_name`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='角色表';

我们对具有不同权限的系统用户进行分类，将其分为不同的角色，并保存到角色表中，如 ”通知管理员“，”权限管理员“等。这样我们只需要为用户关联其对应的角色，就可以完成用户的权限分配。

接下来为角色表创建超级管理员这个角色。

INSERT INTO `sys_role`(id, role_name)
VALUES (1, '超级管理员');
3.sys_user：
CREATE TABLE `sys_user`
(
    `id`          int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `username`    varchar(255)    NOT NULL COMMENT '用户名',
    `password`    varchar(255)    NOT NULL COMMENT '密码',
    `nickname`    varchar(255)    NULL     DEFAULT NULL COMMENT '昵称',
    PRIMARY KEY (`id`),
    UNIQUE KEY `username` (`username`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 10000
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='用户表';

用户表记录了用户的身份信息，这里记录着登录时对登录者进行身份认证所需标准凭证（用户名，密码）。

接下来为用户表创建超级管理员用户。

INSERT INTO `sys_user`(id, username, password, nickname)
VALUES (10001, 'admin', '123456', '超级管理员');
4.sys_role_permission:
CREATE TABLE `sys_role_permission`
(
    `id`            int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time`   timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time`   timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `role_id`       int(4)          NOT NULL COMMENT '角色id',
    `permission_id` int(4)          NOT NULL COMMENT '权限id',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_role_id_permission_id` (`role_id`, `permission_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='角色-权限关联表';

一个角色可以拥有多个权限，这些关联关系将由单独的关联表负责：角色-权限关联表。

接下来角色-权限关联表创建后为超级管理员分配所有权限：

INSERT INTO `sys_role_permission`(role_id, permission_id)
VALUES (1, 101),
       (1, 102),
       (1, 103),
       (1, 104),

       (1, 301),
       (1, 302),
       (1, 303),
       (1, 304),

       (1, 501),
       (1, 502),
       (1, 503),
       (1, 504);
5.sys_user_role :
CREATE TABLE `sys_user_role`
(
    `id`          int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `user_id`     int(4)          NOT NULL COMMENT '用户id',
    `role_id`     int(4)          NOT NULL COMMENT '角色id',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_user_role` (`user_id`, `role_id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 10000
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='用户-角色关联表';

一个用户可以拥有多个角色，这些关联关系将由单独的关联表负责：用户-角色关联表。

接下来创建用户-角色关联表后为将超级管理员的角色与用户关联：

INSERT INTO `sys_user_role`(user_id, role_id)
VALUES (10001, 1);
6.notify：
CREATE TABLE `notify`
(
    `id`          int(4) unsigned NOT NULL AUTO_INCREMENT,
    `insert_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp       NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

    `user_id`     int(4)          NOT NULL COMMENT '创建用户id',
    `content`     text            NOT NULL COMMENT '通知内容',
    PRIMARY KEY (`id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_general_ci COMMENT ='通知表';

2.初始化项目

继续使用上一篇文章中创建的项目，添加必要的初始依赖。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.modelmapper</groupId>
            <artifactId>modelmapper</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.5.3</version>
        </dependency>

2.1 创建分页工具类

对于需要进行分页的数据集，我们需要为其定义一个统一的数据结构，这里将其定义到 PageModel.java 中。创建common包，在该包下创建PageModel.java类。

@Data
public class PageModel<T> implements Serializable {
    private int pageNum;
    private int pageSize;
    private long total;
    private int pages;
    private List<T> list;
}

2.2 统一异常处理

1.导致请求处理失败的错误：由于应用存在未解决的 bug 或依赖的资源报错而引起的错误，如试图打开不存在文件导致的文件 io 错误；网络请求超时，网络 io 错误；或者是强依赖的三方资源报错；甚至是操作系统 OOM，SOF 等。如果遇到这些错误，用户的请求往往无法继续处理，我们能做的只有给用户提示请求处理失败。

2.非法用户输入引起的错误：用户（这里的用户不仅仅指实际用户，也指 API 使用者）输入是不可预测的，难免输入系统无法处理的内容，我们应该尽可能多的主动监测这类错误，监测到时先中断请求，并提示用户需要进行修正，然后才能再次发起请求。

3.进行处理后仍有可能使请求成功完成的错误：这类错误在 java 中我们可以通过 try - catch - finally 进行处理。

在common包下创建两类异常，用于作为上述异常的代表。
ServiceException.java

public class ServiceException extends RuntimeException {
    public ServiceException() {
    }

    public ServiceException(String message) {
        super(message);
    }

    public ServiceException(String message, Throwable cause) {
        super(message, cause);
    }

    public ServiceException(Throwable cause) {
        super(cause);
    }

    public ServiceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

UserInputException

public class UserInputException extends RuntimeException {
    public UserInputException(String message) {
        super(message);
    }
}

接着提供统一的返回结果类，出现异常错误，同样需要使用统一的返回结果返回数据，这里使用使用Spring Boot自带的返回响应包装类。在common包下创建Results.java类。
Results

public class Results {

    public static ResponseEntity success() {
        ResponseEntity rm = new ResponseEntity(HttpStatus.OK);
        return rm;
    }

    public static ResponseEntity userInputError(String msg) {
        ResponseEntity rm = new ResponseEntity(msg, HttpStatus.BAD_REQUEST);
        return rm;
    }

    public static ResponseEntity error(String msg) {
        ResponseEntity rm = new ResponseEntity(msg, HttpStatus.INTERNAL_SERVER_ERROR);
        return rm;
    }

    public static <T extends Serializable> ResponseEntity<T> success(T data) {
        ResponseEntity<T> rm = new ResponseEntity<T>(data, HttpStatus.OK);
        return rm;
    }
}

然后在 Spring 提供的 ControllerAdvice 中统一处理，创建api包，在该包下创建ExceptionController.java类，使用 ControllerAdvice 统一处理错误。
ExceptionController

@Slf4j
@ControllerAdvice
public class ExceptionController {


    /**
     * 出现UserInputException异常时，该方法会处理请求返回响应
     * @param e
     * @return
     */
    @ExceptionHandler({UserInputException.class})
    @ResponseBody
    public ResponseEntity userInputException(UserInputException e) {
        log.warn(e.getMessage());
        return Results.userInputError(e.getMessage());
    }


    /**
     * 出现ServiceException异常时，该方法会处理请求返回响应
     * @param e
     * @return
     */
    @ExceptionHandler({ServiceException.class})
    @ResponseBody
    public ResponseEntity serviceException(ServiceException e) {
        log.error("未知错误", e);
        return Results.error("未知错误");
    }
}

2.3 集成Swagger2接口文档

swagger 可以帮助我们自动生成 API 文档，节省了维护文档的时间，并且可一完成接口的基本测试。

2.3.1 添加依赖
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
2.3.2 启用 Swagger2

在 Application.java 中添加 @EnableSwagger2 注解启用 Swagger2。

@SpringBootApplication
@EnableSwagger2
public class SpringbootshiroApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootshiroApplication.class, args);
    }
}
2.3.3 进行简要测试

在包api下，创建testController.java类，在该类中使用Swagger2接口文档。

@RestController
public class testController {


    /**
     * 简要测试Swagger2
     * @return
     */
    @GetMapping("/hello")
    @ApiOperation("简单的测试")
    public String test(){
        return "hello world";
    }
}

启动后打开 http://localhost:8080/swagger-ui.html 页面。此时出现项目启动报错，我们看看具体的错误：

org.springframework.context.ApplicationContextException: Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException

出现以上错误，是由Springfox的一个bug引起的。具体来说，它假设MVC的路径匹配将使用基于Ant-based的路径匹配器，而不是基于PathPattern-based的匹配器。基于PathPattern-based的匹配已经是一个选项，并且是SpringBoot2.6的默认选项。

因此，如Spring Boot 2.6发行说明中所述，您可以通过在application.properties文件中将Spring.mvc.pathmatch.matching-strategy设置为ant path matcher来恢复Springfox假定将使用的配置。请注意，只有在不使用Spring Boot的执行器时，此功能才起作用。无论配置的匹配策略如何，执行器始终使用基于路径模式的解析。如果您想在Spring Boot 2.6及更高版本中将其与执行器一起使用，则需要对Springfox进行更改。

所以我们在主配置中添加一个配置：

# 解决集成Swagger2后启动报错
spring.mvc.pathmatch.matching-strategy = ant_path_matcher

继续启动后打开 http://localhost:8080/swagger-ui.html 页面。
在这里插入图片描述
可以看到Swagger2接口文档被集成到Spring Boot项目中。

3.使用mybatis逆向工程

这里持久层使用mybatis框架，该框架可以使用简单的配置自动生成必要的Entity，Dao，Mapper文件。

3.1 添加依赖及插件

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

		<!-- mybatis-generator 自动生成代码插件 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                    <configurationFile>${basedir}/src/main/resources/generator/generatorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                </configuration>
            </plugin>

3.2 添加 generatorConfig.xml 配置文件

在resources/generator 目录下创建 generatorConfig.xml 配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <!-- 数据库驱动：选择你的本地数据库驱动包 -->
    <classPathEntry  location="/Users/xuzhi/devTools/local-maven/mysql/mysql-connector-java/8.0.22/mysql-connector-java-8.0.22.jar"/>
    <context id="DB2Tables"  targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <!-- 是否去除自动生成的注释 true：是； false：否 -->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!-- 数据库链接URL，用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://127.0.0.1:3306/acs" userId="root" password="12345678">
        </jdbcConnection>
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!-- 生成模型的包名和位置 -->
        <javaModelGenerator targetPackage="com.picacho.springbootshiro.entity" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 生成映射文件的包名和位置 -->
        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- 生成DAO的包名和位置 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.picacho.springbootshiro.dao" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>


        <!-- 要生成的表 tableName 是数据库中的表名或视图名 domainObjectName 是实体类名 -->
        <table tableName="sys_permission" domainObjectName="SysPermission" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"></table>

        <table tableName="sys_role" domainObjectName="SysRole" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"/>

        <table tableName="sys_role_permission" domainObjectName="SysRolePermission" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"/>

        <table tableName="sys_user" domainObjectName="SysUser" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"/>

        <table tableName="sys_user_role" domainObjectName="SysUserRole" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"/>

        <table tableName="notify" domainObjectName="Notify" enableCountByExample="false"
               enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"/>

    </context>
</generatorConfiguration>

按照如下方式启动插件，生成我们需要的代码，如下图为生成后的文件。
在这里插入图片描述
注意生成的Dao接口还没有被注入到Spring容器中，所以需要我们手动添加注解，提示Sprin扫描这些Dao注入到容器中。

  • 第一种是在每个Dao接口上添加@Mapper注解。
  • 第二种在启动类上添加@MapperScan注解，并且指定扫描路径，这里是"com.picacho.springbootshiro.dao"。

这里我们选择第二种较为方便些。

3.3 添加mybatis配置

在resources文件夹下添加mybatis-config.xml文件，配置生成Entity，Dao，Mapper文件的基本配置。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <setting name="useGeneratedKeys" value="true"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="logImpl" value="SLF4J"/>

        <setting name="cacheEnabled" value="true"/>
        <setting name="localCacheScope" value="SESSION"/>
    </settings>

    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">

            <!-- 4.0.0以后版本可以不设置该参数 -->
            <!--<property name="dialect" value="mysql"/>-->

            <!-- 该参数默认为false -->
            <!-- 设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用 -->
            <!-- 和startPage中的pageNum效果一样-->
            <property name="offsetAsPageNum" value="true"/>

            <!-- 该参数默认为false -->
            <!-- 设置为true时，使用RowBounds分页会进行count查询 -->
            <property name="rowBoundsWithCount" value="true"/>

            <!-- 设置为true时，如果pageSize=0或者RowBounds.limit = 0就会查询出全部的结果 -->
            <!-- （相当于没有执行分页查询，但是返回结果仍然是Page类型）-->
            <property name="pageSizeZero" value="true"/>

            <!-- 3.3.0版本可用 - 分页参数合理化，默认false禁用 -->
            <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
            <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
            <property name="reasonable" value="false"/>

            <!-- 3.5.0版本可用 - 为了支持startPage(Object params)方法 -->
            <!-- 增加了一个`params`参数来配置参数映射，用于从Map或ServletRequest中取值 -->
            <!-- 可以配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置映射的用默认值 -->
            <!-- 不理解该含义的前提下，不要随便复制该配置 -->
            <property name="params" value="pageNum=pageHelperStart;pageSize=pageHelperRows;"/>

            <!-- 支持通过Mapper接口参数来传递分页参数 -->
            <property name="supportMethodsArguments" value="false"/>

            <!-- always总是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page -->
            <property name="returnPageInfo" value="none"/>
        </plugin>
    </plugins>
</configuration>
  • useGeneratedKeys：允许 JDBC 支持自动生成主键，这样 Mapper（Mapper 主要有两种形式：XML 和 java 注解）中的 insert 操作会将自增的 id 回填到 Entity 中。useGeneratedKeys 是一个全局配置，但只对接口映射器（注解的方式）有效，对 XML 无效，因此在 XML 中我们还是需要为每个 insert 语句进行下面的指定：
<insert id="insert" useGeneratedKeys="true" keyProperty="id"></insert>
  • mapUnderscoreToCamelCase：将下划线风格的数据库列名自动映射为 java 字段的驼峰风格。
  • logImpl：将 SQL 执行语句通过日志打印出来。
  • localCacheScope：控制一级缓存生效范围，有 SESSION 和 STATEMENT 两种。MyBatis 会将 Mapper 中的查询语句（）映射为 MappedStatement，执行查询时 MappedStatement 及其查询参数和返回结果会被缓存，下次同样的查询被执行时可以直接从缓存中获取结果。
  • cacheEnabled：控制二级缓存，一级缓存的最大生效范围是 SESSION，如果需要在多个 SESSION（即跨 SqlSession 实例）中进行缓存共享，就需要启用二级缓存。

3.4 在主配置文件种添加数据库相关配置

spring.datasource.url = jdbc:mysql://localhost:3306/acs?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = 12345678
spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name = com.mysql.jdbc.Driver

4.Shiro配置

4.1 引入依赖

在Spring Boot项目中，Shiro 官方提供了专门的 Starter：shiro-spring-boot-web-starter依赖来简化集成。

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

4.2 配置Shiro

在主配置文件中对Shiro进行配置。

# Shiro配置
shiro.web.enabled = true
shiro.sessionManager.sessionIdCookieEnabled = true
shiro.sessionManager.sessionIdUrlRewritingEnabled = true
shiro.loginUrl = /login.html
  • web.enabled 控制是否启用 Shiro 框架，true 表示启用，在项目开发阶段为了跳过安全检查可以设置为 false。
  • sessionManager.sessionIdCookieEnabled：启用或停用通过 cookie 的会话状态保持，false 表示不允许将 sessionID（实际上是 JSESSIONID）放到 cookie 中。
  • sessionManager.sessionIdUrlRewritingEnabled：是否允许将 sessionID 放到 URL 中，以 URL 参数的方式进行传递，当sessionManager.sessionIdCookieEnabled 设置为 true 时该项可以设为 false。
  • loginUrl 参数用来指定登录页面，当用户访问没有权限的 URL 时将自动跳转到该页面。

4.3 实现ACSRealm

Realm 是 Shiro 的核心组件，是用户身份信息，权限以及角色信息的提供者，从系统数据源，例如mysql中获取数据，然后转交给 Shiro 进行身份认证和权限管理，开发中一般基于其抽象子类 AuthorizingRealm 进行扩展。

创建config包，在该包下创建ACSRealm.java类，ACSRealm 将继承 AuthorizingRealm 。AuthorizingRealm 定义了两个抽象方法：doGetAuthorizationInfo 和 doGetAuthenticationInfo，这两个方法是 Shiro 进行身份认证和授权的关键。

认证

@Component
public class ACSRealm extends AuthorizingRealm {

    @Autowired
    private SysUserMapper sysUserMapper;

    /**
     * 认证
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        SysUser user = sysUserMapper.findByUsername(username);
        if (user == null) {
            throw new UnknownAccountException();
        }

        String pwd = user.getPassword();
        String password = new String(((char[]) token.getCredentials()));
        if (!pwd.equals(password)) {
            throw new IncorrectCredentialsException();
        }
        return new SimpleAuthenticationInfo(username, pwd, getName());
    }
}

    /**
     * 通过用户名查询用户
     * @param username
     * @return
     */
    SysUser findByUsername(String username);

  <select id="findByUsername" resultType="com.picacho.springbootshiro.entity.SysUser">
    select
    <include refid="Base_Column_List"/>
    from sys_user
    where username = #{username}
  </select>

授权

@Component
public class ACSRealm extends AuthorizingRealm {

    @Autowired
    private SysUserMapper sysUserMapper;

    /**
     * 授权
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        Collection<Permission> permissions = loadPermissions(principals);
        authorizationInfo.addObjectPermissions(permissions);
        return authorizationInfo;
    }


    private Collection<Permission> loadPermissions(PrincipalCollection principals) {
        String username = (String) principals.getPrimaryPrincipal();
        List<String> ps = sysUserMapper.findAllPermissions(username);
        if (CollectionUtils.isEmpty(ps)) {
            return null;
        }
        return ps.stream().map(WildcardPermission::new).collect(Collectors.toList());
    }
}

    /**
     * 通过用户名查询权限
     * @param username
     * @return
     */
    List<String> findAllPermissions(String username);

  <select id="findAllPermissions" resultType="java.lang.String">
    SELECT sp.permission_code
    FROM sys_user su
           LEFT JOIN sys_user_role sur ON su.id = sur.user_id
           LEFT JOIN sys_role_permission srp ON sur.role_id = srp.role_id
           LEFT JOIN sys_permission sp ON srp.permission_id = sp.id
    WHERE username = #{username}
  </select>

4.4 配置 SecurityManager 和过滤器

SecurityManager 的配置比较简单，主要是将我们自己的 ACSRealm 配置给 SecurityManager。在config包下创建ShiroConfig.java类。

@Configuration
public class ShiroConfig {

    @Bean
    DefaultWebSecurityManager securityManager(ACSRealm realm) {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(realm);
        return manager;
    }
}

接下来需要配置 Shiro 过滤器，Shiro 过滤器可以指定对 URL 路径应用什么样的访问控制策略，如控制某一 URL 允许匿名访问，或者需要完成身份认证（登录）后才能访问等。

    @Bean
    ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
        // swagger 文档相关的接口允许匿名访问
        chainDefinition.addPathDefinition("/swagger**", "anon");
        chainDefinition.addPathDefinition("/webjars**", "anon");

        // 登录接口允许匿名访问
        chainDefinition.addPathDefinition("/api/login", "anon");

        // 所有 api 开头的接口都需要登录
        chainDefinition.addPathDefinition("/api/**", "authc");
        return chainDefinition;
    }

Shiro 的过滤器都定义在 org.apache.shiro.web.filter 包中，有唯一的简写字符串与之对应，常见的过滤器有下面几种：

  • anon：允许匿名访问。
  • authc：需要完成身份认证（登录）后才能访问。
  • perms：可指定访问者必须具备的权限，如：“perms[role:add, user:list]”，表示访问者需要同时具备 “role:add” 和 “user:list” 权限才能访问当前路径。
  • user：必须存在用户，身份认证通过或通过“记住我”认证通过的都可以访问。

4.5 简单测试一下

创建controller包，并在该包下创建LoginController类中，添加跳转至login.html的方法。

@RestController
public class LoginController {

    @GetMapping("/login.html")
    public String loginPage() {
        return "<p><h1>" +
                "模拟登录界面" +
                "</h1><h5>" +
                "有两种情况该页面被打开:" +
                "</h5><ul><li>" +
                "用户主动打开" +
                "</li><li>" +
                "无权限时自动跳转" +
                "</li></ul></p>";
    }
}

测试一下：访问此路径http://localhost:8080/api/hello，由于没有权限会被映射到http://localhost:8080/login.html路径，因此会出现如下画面。
在这里插入图片描述
在这里插入图片描述
demo源码下载地址：demo源码下载

详解spring整合shiro权限管理与数据库设计
08-30
主要介绍了详解spring整合shiro权限管理与数据库设计，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot与Shiro实现权限管理
11-12
本篇文章将深入探讨如何利用Spring Boot的便捷性和Shiro的安全特性，构建一个完善的权限管理系统。 首先，Spring Boot是基于Spring框架的简化版本，它极大地减少了配置工作，通过“约定优于配置”的原则，使得...
SpringBoot整合Mybatis、MySQL、Shiro实现登录认证和授权
jike11231的博客
12-16 936
一、Apache Shiro 一级目录 1、什么是Shiro Shiro是Java的一个安全框架。，是一个权限管理的框架，实现 用户认证、用户授权。 2、Shiro的优点 (1)Shiro将安全认证相关的功能抽取出来组成一个框架，使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。  (2)Shiro使用广泛，Shiro可以运行在web应用，非web应用，集群分布式应用中越来越多的用户开始使用Shiro。  (3)Java领域中spring security(原名Acegi)也是一个开源
SpringBoot整合Shiro实现权限控制
Willing卡卡的博客
09-05 446
本文主要分享了SpringBoot整合Shiro实现权限控制的案例，Shiro的认证流程：包括环境的搭建、数据库的添加、实体类映射文件、使用源生Shiro、MD5加密后的密钥登录问题、基于注解的开发（均附源码）；
springboot + shiro 实现登录认证和权限控制
baidu_18987603的博客
04-16 3031
这段时间在学习springboot，在spring security和shiro中选择了shiro，原因就是shiro学习成本比较低，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西,，而且粗粒度也可以根据需要来定制，所以使用小而简单的Shiro就足够了。 本文主要参考了z77z的SpringBoot+shiro整合学习之登录认证和权限控制 简介
spring boot+shiro 权限认证管理案例
12-20
通过以上步骤，我们可以构建一个集成了 Spring Boot 和 Shiro 的权限认证管理系统，能够实现用户登录、权限校验、会话管理等功能，同时利用缓存提升系统性能。在实际开发中，还可以根据需求扩展 Shiro 功能，例如...
SpringBoot+jwt+shiro实现登录验证及接口权限校验
zhang_199911的博客
11-10 8417
刚出炉的SpringBoot＋JWT＋Token＋Shiro实现接口登录验证，权限管理(RBAC模型)，源码详细，注释清晰~
Springboot整合Shiro-多权限调用接口问题
weixin_47208793的博客
09-10 661
问题 ​ 在开发中，我们希望不同的角色权限可以调用同一个API接口，例如/user/**相关API既可以由拥有admin权限的角色调用，也可以由拥有student权限的角色调用，这时我们可能会有2种方案 方案一 filterMap.put("/user/**","roles[admin]"); filterMap.put("/user/**","roles[student]"); 方案二 filterMap.put("/user/**","roles[admin,student]"); ​ 但实际上，以
shiro权限所需5表
04-08
shiro权限所需5表，只是简单的权限控制，不复杂，适合新手！
shiro数据库设计 五张表
11-07
shiro权限框架数据库设计，附少量数据，仅供测试，非实际项目
Spring Boot Shiro权限管理
热门推荐
爱笑的博客
08-28 2万+
转:http://412887952-qq-com.iteye.com/blog/2299777 (1). Shiro简单介绍 Shiro是Apache下的一个开源项目，我们称之为Apache Shiro。它是一个很易用与Java项目的的安全框架，提供了认证、授权、加密、会话管理，与 Spring Security 一样都是做一个权限的安全框架，但是与Spring Security
SpringBoot+Shiro+JWT实现登录和权限控制
jike11231的博客
10-21 1350
SpringBoot+Shiro+JWT实现登录和权限控制认证和授权Shiro 和JWT的简单介绍实现认证和授权的整体思路数据库表设计代码实现登录JWT生成token(附带验证的一些工具类)过滤器自定义MyRealmMyRealm的解释Shiro注解代码测试登录未携带token访问资源携带token访问需要guest角色但却是admin的tokenguest权限guest的token权限不足的情况有权限访问 认证和授权 认证（authentication） 在程序中认证要做的事情主要是搞明白访问者是谁，他有
SpringBoot整合Shiro实现权限控制，springmvc实战教程
最新发布
03-22 1000
**自定义安全策略*/@Autowired//授权@Override//根据用户名查询用户权限=null){//权限去重//给shiro的安全管理器授权//认证@Override//根据用户名查询用户信息=null){/**自定义shiro配置管理程序加载时，已经初始化*/@Configuration //标注此类为一个配置管理类，自动备spring管理@Bean。
springboot集成springsecurity实现权限管理
m0_66725604的博客
03-22 1242
简介 Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是保护基于Spring的应用程序的事实标准。 Spring Security是一个专注于为Java应用程序提供身份验证和授权的框架。与所有Spring项目一样，Spring Security的真正威力在于它可以容易地扩展以满足定制需求。 spring是非常流行和成功的Java应用开发框架，Spring Security正是Spring家族中的成员。Spring Security基于Spring框架，提供了一套We
spring boot后台管理系统，spring security权限控制
zwzw1219的博客
09-14 2万+
spring security版 源码地址：https://gitee.com/zhang.w/boot-security.git shiro版 源码地址：https://gitee.com/zhang.w/boot-backend.git 随着spring boot的出现，java又上升了一个层次，以往tomcat部署war的形式也改变了，现在可以直接一个jar包、一行命令，真正实现一次编译...
SpringBoot权限管理-按钮级别权限
普通人一枚
04-27 3522
0.需要按钮具备权限标识 1.存储数据库列表 . 2.自定义注解,使其在按钮执行之前执行这个注解,是否有权CRUD /** * 写一个自定义注解 使其在按钮执行之前执行这个注解,是否有权CRUD */ @Retention(RetentionPolicy.SOURCE) @Target(ElementType.METHOD) public @interface HasPerm { String perm() default ""; } ...
shiro之授权（二） Permission（*）
weixin_42408447的博客
11-17 576
字符串通配符权限 规则：“资源标识符：操作：对象实例ID” 即对哪个资源的哪个实例可以进行什么操作。 其默认支持通配符权限字符串，“:”表示资源/操作/实例的分割；“,”表示操作的分割；“*”表示任意资源/操作/实例。 1. 单个资源单个权限 subject().checkPermissions("system:user:update"); 用户拥有资源"system:user"的"update"权限 2. 单个资源多个权限 ini配置文件 [users] zhang=123,role1,role2,ro
Spring Boot结合Shiro实现权限认证与缓存管理
### Spring Boot+Shiro 权限认证管理案例知识点解析 #### 一、Spring Boot与Shiro简介 ##### 1. Spring Boot Spring Boot是Spring开源组织的一个子项目，它提供了一种快速使用Spring的方式，通过Spring Boot可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

picacho_pkq

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值