权限框架之Shiro详解

文章大纲

一、权限框架介绍
二、shiro基础介绍
三、spring boot整合shiro代码实战
四、项目源码与资料下载
五、参考文章

 

一、权限框架介绍

1. 什么是权限管理

  权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
  权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。
1.1 用户身份认证
  身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件key等刷卡系统，则需要刷卡。

用户名密码身份认证流程：

 

1.2 授权流程
  授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。

 

2. 常见权限框架

2.1 shiro简介
  apache shiro是java的一个安全框架。目前，使用apache shiro的人越来越多，因为它相当简单，对比spring security，可能没有spring security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的shiro就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。

2.2 spring security
  spring security是一个能够为基于spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在spring应用上下文中配置的bean，充分利用了spring ioc，di（控制反转inversion of control ,di:dependency injection 依赖注入）和aop（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。它是一个轻量级的安全框架，它确保基于spring的应用程序提供身份验证和授权支持。它与spring mvc有很好地集成，并配备了流行的安全算法实现捆绑在一起。安全主要包括两个操作“认证”与“验证”（有时候也会叫做权限控制）。“认证”是为用户建立一个其声明的角色的过程，这个角色可以一个用户、一个设备或者一个系统。“验证”指的是一个用户在你的应用中能够执行某个操作。在到达授权判断之前，角色已经在身份认证过程中建立了。

2.3 shiro和spring security比较
（1）shiro比spring更容易使用，实现和最重要的理解
（2）spring security更加知名的唯一原因是因为品牌名称
（3）“spring”以简单而闻名，但讽刺的是很多人发现安装spring security很难
（4）spring security却有更好的社区支持
（5）apache shiro在spring security处理密码学方面有一个额外的模块
（6）spring-security 对spring 结合较好，如果项目用的springmvc ，使用起来很方便。但是如果项目中没有用到spring，那就不要考虑它了。
（7）shiro 功能强大、且 简单、灵活。是apache 下的项目比较可靠，且不跟任何的框架或者容器绑定，可以独立运行

二、shiro基础介绍

1. shiro三个核心组件

1.1 subject
  subject：即“当前操作用发户”。但是，在shiro中，subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（daemon account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是shiro的“用户”概念。subject代表了当前用户的安全操作，securitymanager则管理所有用户的安全操作。

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

1.3 realm
  realm充当了shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，shiro会从应用配置的realm中查找用户及其权限信息。
  从这个意义上讲，realm实质上是一个安全相关的dao：它封装了数据源的连接细节，并在需要时将相关数据提供给shiro。当配置shiro时，你必须至少指定一个realm，用于认证和（或）授权。配置多个realm是可以的，但是至少需要一个。
  shiro内置了可以连接大量安全数据源（又名目录）的realm，如ldap、关系数据库（jdbc）、类似ini的文本配置资源以及属性文件等。如果缺省的realm不能满足需求，你还可以插入代表自定义数据源的自己的realm实现。

2. shiro相关类介绍

（1）authentication 认证 ---- 用户登录
（2）authorization 授权 --- 用户具有哪些权限
（3）cryptography 安全数据加密
（4）session management 会话管理
（5）web integration web系统集成
（6）interations 集成其它应用，spring、缓存框架

3. shiro 特点

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

三、spring boot整合shiro代码实战

1. spring boot基础

https://www.cnblogs.com/wuxiaochang/p/10877266.html

2. 创建spring boot的基础项目

2.1 新建maven项目

 

 

 

创建后项目结构如下：

 

2.2 pom.xml中添加依赖

<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>

    <!-- 继承spring boot的默认父工程 -->
    <!-- spring boot 父工程 -->
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.5.4.release</version>
    </parent>

    <groupid>com.itheima</groupid>
    <artifactid>springboot-shiro</artifactid>
    <version>0.0.1-snapshot</version>


    <!-- 导入依赖 -->
    <dependencies>

        <!-- 导入web支持：springmvc开发支持，servlet相关的程序 -->
        <!-- web支持，springmvc， servlet支持等 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
    </dependencies>


    <!-- 修改参数 -->
    <properties>
        <!-- 修改jdk的编译版本为1.8 -->
        <java.version>1.8</java.version>
    </properties>
</project>

2.3 编写测试controller类
com.itheima.controller包下新建usercontroller.java

package com.itheima.controller;

import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.responsebody;

@controller
public class usercontroller {

    /**
     * 测试方法
     */
    @requestmapping("/hello")
    @responsebody
    public string hello(){
        system.out.println("usercontroller.hello()");
        return "ok";
    }
}

2.4 导入thymeleaf页面模块
pom.xml文件中添加依赖

<!-- 导入thymeleaf依赖 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-thymeleaf</artifactid>
        </dependency>

usercontroller.java类中添加测试方法

    /**
     * 测试thymeleaf
     */
    @requestmapping("/testthymeleaf")
    public string testthymeleaf(model model){
        //把数据存入model
        model.addattribute("name", "吴先生");
        //返回test.html
        return "test";
    }

2.5 添加thymeleaf页面模块
在src/main/resource目录下创建templates目录，然后创建test.html页面

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>测试thymeleaf的使用</title>
</head>
<body>
<h3 th:text="${name}"></h3>
</body>
</html>

 

2.6 运行项目并访问
运行项目

 

访问项目

 

 

3. spring boot与shiro整合实现用户认证

3.1 分析shiro的核心api
subject： 用户主体（把操作交给securitymanager）
securitymanager：安全管理器（关联realm）
realm：shiro连接数据的桥梁

3.2 导入shiro与spring整合依赖
pom.xml文件中添加依赖

<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>

    <!-- 继承spring boot的默认父工程 -->
    <!-- spring boot 父工程 -->
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.5.4.release</version>
    </parent>

    <groupid>com.itheima</groupid>
    <artifactid>springboot-shiro</artifactid>
    <version>0.0.1-snapshot</version>


    <!-- 导入依赖 -->
    <dependencies>

        <!-- 导入web支持：springmvc开发支持，servlet相关的程序 -->
        <!-- web支持，springmvc， servlet支持等 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

        <!-- 导入thymeleaf依赖 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-thymeleaf</artifactid>
        </dependency>

        <!-- shiro与spring整合依赖 -->
        <dependency>
            <groupid>org.apache.shiro</groupid>
            <artifactid>shiro-spring</artifactid>
            <version>1.4.0</version>
        </dependency>

        <!-- 导入mybatis相关的依赖 -->
        <dependency>
            <groupid>com.alibaba</groupid>
            <artifactid>druid</artifactid>
            <version>1.0.9</version>
        </dependency>

        <!-- mysql -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
        </dependency>

        <!-- springboot的mybatis启动器 -->
        <dependency>
            <groupid>org.mybatis.spring.boot</groupid>
            <artifactid>mybatis-spring-boot-starter</artifactid>
            <version>1.1.1</version>
        </dependency>

        <!-- thymel对shiro的扩展坐标 -->
        <dependency>
            <groupid>com.github.theborakompanioni</groupid>
            <artifactid>thymeleaf-extras-shiro</artifactid>
            <version>2.0.0</version>
        </dependency>

    </dependencies>


    <!-- 修改参数 -->
    <properties>
        <!-- 修改jdk的编译版本为1.8 -->
        <java.version>1.8</java.version>
        <!-- 修改thymeleaf的版本 -->
        <thymeleaf.version>3.0.2.release</thymeleaf.version>
        <thymeleaf-layout-dialect.version>2.0.4</thymeleaf-layout-dialect.version>
    </properties>

    <build>
        <!--解决项目运行后mapper.xmlw文件找不到情况-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

3.3 resources下配置
新建application.properties文件

spring.datasource.driverclassname=com.mysql.jdbc.driver
spring.datasource.url=jdbc:mysql://localhost:3306/shiro_test
spring.datasource.username=root
spring.datasource.password=147258qq

spring.datasource.type=com.alibaba.druid.pool.druiddatasource

mybatis.type-aliases-package=com.itheima.domain

templates文件夹下加入相关模板页面

add.html

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>用户添加页面</title>
</head>
<body>
用户添加
</body>
</html>

update.html

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>用户更新页面</title>
</head>
<body>
用户更新
</body>
</html>

login.html

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>登录页面</title>
</head>
<body>
<h3>登录</h3>
<h3 th:text="${msg}" style="color: red"></h3>

<form method="post" action="login">
    用户名:<input type="text" name="name"/><br/>
    密码：<input type="password" name="password"/><br/>
    <input type="submit" value="登录"/>
</form>
</body>
</html>

noauth.html

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>未授权提示页面</title>
</head>
<body>
亲，你未经授权访问该页面
</body>
</html>

 

3.4 新建shiro相关配置
com.itheima.shiro包下新建shiroconfig.java类

package com.itheima.shiro;

import java.util.linkedhashmap;
import java.util.map;

import org.apache.shiro.spring.web.shirofilterfactorybean;
import org.apache.shiro.web.mgt.defaultwebsecuritymanager;
import org.springframework.beans.factory.annotation.qualifier;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

import at.pollux.thymeleaf.shiro.dialect.shirodialect;

/**
 * shiro的配置类
 * 
 * 关于configuration的讲解，可参考一下博客：https://www.cnblogs.com/wuxiaochang/p/10877266.html
 * @author lenovo
 *
 */
@configuration
public class shiroconfig {

    /**
     * 创建shirofilterfactorybean
     */
    @bean
    public shirofilterfactorybean getshirofilterfactorybean(@qualifier("securitymanager")defaultwebsecuritymanager securitymanager){
        
        shirofilterfactorybean shirofilterfactorybean = new shirofilterfactorybean();
        
        //设置安全管理器
        shirofilterfactorybean.setsecuritymanager(securitymanager);
        
        //添加shiro内置过滤器
        /**
         * shiro内置过滤器，可以实现权限相关的拦截器
         *    常用的过滤器：
         *       anon: 无需认证（登录）可以访问
         *       authc: 必须认证才可以访问
         *       user: 如果使用rememberme的功能可以直接访问
         *       perms： 该资源必须得到资源权限才可以访问
         *       role: 该资源必须得到角色权限才可以访问
         */
        map<string,string> filtermap = new linkedhashmap<string,string>();
        /*filtermap.put("/add", "authc");
        filtermap.put("/update", "authc");*/
        
        filtermap.put("/testthymeleaf", "anon");
        //放行login.html页面
        filtermap.put("/login", "anon");
        
        //授权过滤器
        //注意：当前授权拦截后，shiro会自动跳转到未授权页面
        //perms括号中的内容是权限的值
        filtermap.put("/add", "perms[user:add]");
        filtermap.put("/update", "perms[user:update]");
        
        filtermap.put("/*", "authc");
        
        //修改调整的登录页面
        shirofilterfactorybean.setloginurl("/tologin");
        //设置未授权提示页面
        shirofilterfactorybean.setunauthorizedurl("/noauth");
        
        shirofilterfactorybean.setfilterchaindefinitionmap(filtermap);
        
        
        return shirofilterfactorybean;
    }
    
    /**
     * 创建defaultwebsecuritymanager
     * 
     * 里面主要定义了登录，创建subject，登出等操作
     */
    @bean(name="securitymanager")
    public defaultwebsecuritymanager getdefaultwebsecuritymanager(@qualifier("userrealm")userrealm userrealm){
        defaultwebsecuritymanager securitymanager = new defaultwebsecuritymanager();
        //关联realm
        securitymanager.setrealm(userrealm);
        return securitymanager;
    }
    
    /**
     * 创建realm
     */
    @bean(name="userrealm")
    public userrealm getrealm(){
        return new userrealm();
    }
    
    /**
     * 配置shirodialect，用于thymeleaf和shiro标签配合使用
     */
    @bean
    public shirodialect getshirodialect(){
        return new shirodialect();
    }
}

com.itheima.shiro包下新建userrealm.java类

package com.itheima.shiro;

import org.apache.shiro.securityutils;
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.authc.usernamepasswordtoken;
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.subject.subject;
import org.springframework.beans.factory.annotation.autowired;

import com.itheima.domain.user;
import com.itheima.service.userservice;

/**
 * 自定义realm
 * （1）authenticatingrealm：shiro中的用于进行认证的领域，实现dogetauthentcationinfo方法实现用户登录时的认证逻辑；
 * （2）authorizingrealm：shiro中用于授权的领域，实现dogetauthrozitioninfo方法实现用户的授权逻辑，authorizingrealm继承了authenticatingrealm，
 * 所以在实际使用中主要用到的就是这个authenticatingrealm类；
 * （3）authenticatingrealm、authorizingrealm这两个类都是shiro中提供了一些线程的realm接口
 * （4）在与spring整合项目中，shiro的securitymanager会自动调用这两个方法，从而实现认证和授权，可以结合shiro的cachemanager将认证和授权信息保存在缓存中，
 * 这样可以提高系统的处理效率。    
 *
 */
public class userrealm extends authorizingrealm{

    @autowired
    private userservice userserivce;

    /**
     * 执行认证逻辑
     */
    @override
    protected authenticationinfo dogetauthenticationinfo(authenticationtoken arg0) throws authenticationexception {
        system.out.println("执行认证逻辑");

        //编写shiro判断逻辑，判断用户名和密码
        //1.判断用户名  token中的用户信息是登录时候传进来的
        usernamepasswordtoken token = (usernamepasswordtoken)arg0;

        user user = userserivce.findbyname(token.getusername());

        if(user==null){
            //用户名不存在
            return null;//shiro底层会抛出unknowaccountexception
        }

        //2.判断密码
        //第二个字段是user.getpassword()，注意这里是指从数据库中获取的password。第三个字段是realm，即当前realm的名称。
        //这块对比逻辑是先对比username，但是username肯定是相等的，所以真正对比的是password。
        //从这里传入的password（这里是从数据库获取的）和token（filter中登录时生成的）中的password做对比，如果相同就允许登录，
        // 不相同就抛出incorrectcredentialsexception异常。
        //如果认证不通过，就不会执行下面的授权方法了
        return new simpleauthenticationinfo(user,user.getpassword(),"");
    }

    /**
     * 执行授权逻辑
     */
    @override
    protected authorizationinfo dogetauthorizationinfo(principalcollection arg0) {

        //dogetauthorizationinfo方法可能会执行多次，权限判断次数多少，就会执行多少次
        system.out.println("执行授权逻辑1");
        system.out.println("执行授权逻辑2");
        
        //给资源进行授权
        simpleauthorizationinfo info = new simpleauthorizationinfo();
        
        //添加资源的授权字符串
        //info.addstringpermission("user:add");
        
        //到数据库查询当前登录用户的授权字符串
        //获取当前登录用户
        subject subject = securityutils.getsubject();
        user user = (user)subject.getprincipal();
        user dbuser = userserivce.findbyid(user.getid());
        
        info.addstringpermission(dbuser.getperms());
        
        return info;
    }
}

3.5 新建实体类
com.itheima.domain包下新建user.java

package com.itheima.domain;

public class user {
    private integer id;
    private string name;
    private string password;
    private string perms;
    public string getperms() {
        return perms;
    }
    public void setperms(string perms) {
        this.perms = perms;
    }
    public integer getid() {
        return id;
    }
    public void setid(integer id) {
        this.id = id;
    }
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    public string getpassword() {
        return password;
    }
    public void setpassword(string password) {
        this.password = password;
    }
    
}

3.6 创建mapper相关内容
com.itheima.mapper包下新建usermapper.java

package com.itheima.mapper;

import com.itheima.domain.user;

public interface usermapper {

    public user findbyname(string name);
    
    public user findbyid(integer id);
}

com.itheima.mapper包下新建usermapper.xml

<?xml version="1.0" encoding="utf-8" ?>
<!doctype mapper
public "-//mybatis.org//dtd mapper 3.0//en"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 该文件存放crud的sql语句 -->
<mapper namespace="com.itheima.mapper.usermapper">
    
    <select id="findbyname" parametertype="string" resulttype="user">
    select  id, 
        name, 
        password
        from 
        user where name = #{value}
    </select>
    
    <select id="findbyid" parametertype="int" resulttype="user">
        select  id, 
        name, 
        password,
        perms 
        from 
        user where id = #{value}
    </select>
</mapper>

3.7 创建业务逻辑相关内容
com.itheima.service下新建userservice.java

package com.itheima.service;

import com.itheima.domain.user;

public interface userservice {

    public user findbyname(string name);
    
    public user findbyid(integer id);
}

com.itheima.service.impl下新建userserviceimpl.java

package com.itheima.service.impl;

import org.apache.tomcat.util.net.openssl.ciphers.authentication;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import org.springframework.transaction.annotation.transactional;

import com.itheima.domain.user;
import com.itheima.mapper.usermapper;
import com.itheima.service.userservice;

@service
public class userserviceimpl implements userservice{

    //注入mapper接口
    @autowired
    private usermapper usermapper;
    
    @override
    public user findbyname(string name) {
        return usermapper.findbyname(name);
    }

    @override
    public user findbyid(integer id) {
        return usermapper.findbyid(id);
    }

}

3.8 新建controller相关内容
usercontroller.java添加相关代码，最终内容如下：

package com.itheima.controller;

import org.apache.shiro.securityutils;
import org.apache.shiro.authc.authenticationexception;
import org.apache.shiro.authc.incorrectcredentialsexception;
import org.apache.shiro.authc.unknownaccountexception;
import org.apache.shiro.authc.usernamepasswordtoken;
import org.apache.shiro.subject.subject;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.controller;
import org.springframework.ui.model;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.responsebody;

import com.itheima.service.userservice;

@controller
public class usercontroller {

    /**
     * 测试方法
     */
    @requestmapping("/hello")
    @responsebody
    public string hello(){
        system.out.println("usercontroller.hello()");
        return "ok";
    }
    
    @requestmapping("/add")
    public string add(){
        return "/user/add";
    }
    
    @requestmapping("/update")
    public string update(){
        return "/user/update";
    }
    
    @requestmapping("/tologin")
    public string tologin(){
        return "/login";
    }
    
    @requestmapping("/noauth")
    public string noauth(){
        return "/noauth";
    }

    /**
     * 测试thymeleaf
     */
    @requestmapping("/testthymeleaf")
    public string testthymeleaf(model model){
        //把数据存入model
        model.addattribute("name", "吴先生");
        //返回test.html
        return "test";
    }
    
    /**
     * 登录逻辑处理
     */
    @requestmapping("/login")
    public string login(string name,string password,model model){
        system.out.println("name="+name);
        /**
         * 使用shiro编写认证操作
         */
        //1.获取subject
        subject subject = securityutils.getsubject();
        
        //2.封装用户数据
        usernamepasswordtoken token = new usernamepasswordtoken(name,password);
        
        //3.执行登录方法
        try {
            subject.login(token);
            
            //登录成功
            //跳转到test.html
            return "redirect:/testthymeleaf";
        } catch (unknownaccountexception e) {
            //e.printstacktrace();
            //登录失败:用户名不存在，unknownaccountexception是shiro抛出的找不到用户异常
            model.addattribute("msg", "用户名不存在");
            return "login";
        }catch (incorrectcredentialsexception e) {
            //e.printstacktrace();
            //登录失败:密码错误，incorrectcredentialsexception是shiro抛出的密码错误异常
            model.addattribute("msg", "密码错误");
            return "login";
        }
    }
}

3.9 application启动类配置

package com.itheima;

import org.mybatis.spring.annotation.mapperscan;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;

/**
 * springboot启动类
 * @author lenovo
 *
 */
@springbootapplication
//之前是，直接在mapper类上面添加注解@mapper，这种方式要求每一个mapper类都需要添加此注解，麻烦
//通过使用@mapperscan可以指定要扫描的mapper类的包的路径   同时,使用@mapperscan注解多个包 
@mapperscan("com.itheima.mapper")
public class application {

    public static void main(string[] args) {
        springapplication.run(application.class, args);
    }
}

3.10 创建后项目结构

 

3.11 数据库配置
数据库的sql文件可以在项目源码与资料下载中获取，我们创建的数据库名字为shiro_test,具体字段参数如下图所示：

 

往数据库插入一条数据

 

3.12 运行项目并访问

 

 

访问http://localhost:8080/add或者http://localhost:8080/update，可以看到被拦截了，重定向到了登录页面

 

 

访问http://localhost:8080/login，进行登录

 

登录成功

 

我们在数据库添加的权限是修改的，我们试试登录后，访问添加页面

 

可以看到，已经被拦截了

四、项目源码与资料下载

链接：https://pan.baidu.com/s/12ytmozr6ofg6cycvmnbwog
提取码：yswz

五、参考文章

1. https://www.cnblogs.com/jpfss/p/8352031.html
2. https://blog.csdn.net/liyuejin/article/details/77838868
3. http://yun.itheima.com/open/283.html?1810mcgqq