springboot整合shiro，Shiro整合thymleaf标签及MD5加密

一、RBAC介绍

---

1.1 RBAC简介

RBAC是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

在RBAC模型里面，有3个基础组成部分，分别是：用户、角色和权限。

RBAC通过定义角色的权限，并对用户授予某个角色从而来控制用户的权限，实现了用户和权限的逻辑分离，极大地方便了权限的管理，在讲解之前，先介绍一些名词：

User（用户）：每个用户都有唯一的UID识别，并被授予不同的角色

Role（角色）：不同角色具有不同的权限

Permission（权限）：访问权限

用户-角色映射：用户和角色之间的映射关系

角色-权限映射：角色和权限之间的映射

1.2 权限管理

只要有用户参与的系统一般都要有权限管理，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。

权限管理包括用户认证和授权两部分。

二、 用户认证

用户认证，用户去访问系统，系统要验证用户身份的合法性。最常用的用户身份验证的方法：

1、用户名密码方式、2、指纹打卡机、3、基于证书验证方法。。系统验证用户身份合法，用户方可访问系统的资源。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CdzR9dsH-1617348749941)(Pictures\2.png)]

关键对象：

subject：主体，理解为用户,可能是程序，都要去访问系统的资源，系统需要对subject进行身份认证。

principal：身份信息，通常是唯一的，一个主体还有多个身份信息，但是都有一个主身份信息（primary principal）

credential：凭证信息，可以是密码 、证书、指纹。

总结：主体在进行身份认证时需要提供身份信息和凭证信息。

三、用户授权

---

用户授权，简单理解为访问控制，在用户认证通过后，系统对用户访问资源进行控制，用户具有资源的访问权限方可访问。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hGMI98co-1617348749943)(Pictures\3.png)]

关键对象

授权的过程理解为：who对what(which)进行how操作。

who：主体即subject，subject在认证通过后系统进行访问控制。

what(which)：资源(Resource)，subject必须具备资源的访问权限才可访问该 资源。资源比如：系统用户列表页面、商品修改菜单、商品id为001的商品信息。

资源分为资源类型和资源实例：

系统的用户信息就是资源类型，相当于java类。

系统中id为001的用户就是资源实例，相当于new的java对象。

how：权限/许可(permission) ，针对资源的权限或许可，subject具有permission访问资源，如何访问/操作需要定义permission，权限比如：用户添加、用户修改、商品删除。

四、权限模型

---

主体（账号、密码）

资源（资源名称、访问地址）

权限（权限名称、资源id）

角色（角色名称）

角色和权限关系（角色id、权限id）

主体和角色关系（主体id、角色id）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R3tONGWd-1617348749946)(Pictures\4.png)]

通常企业开发中将资源和权限表合并为一张权限表，如下：

资源（资源名称、访问地址）

权限（权限名称、资源id）

合并为：权限（权限名称、资源名称、资源访问地址）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gEtgjZ6K-1617348749947)(Pictures\5.png)]

上图常被称为权限管理的通用模型，不过企业在开发中根据系统自身的特点还会对上图进行修改，但是用户、角色、权限、用户角色关系、角色权限关系是需要去理解的。

分配权限：用户需要分配相应的权限才可访问相应的资源。权限是对于资源的操作许可，通常给用户分配资源权限需要将权限信息持久化，比如存储在关系数据库中，把用户信息、权限管理、用户分配的权限信息写到数据库（权限数据模型）。

五、Shiro介绍

---

shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权，功能强大、且 简单、灵活，且不跟任何的框架或者容器绑定，可以独立运行。

spring中有spring security (原名Acegi)，是一个权限框架，使用起来很方便，和spring依赖过于紧密。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qQfcNRdD-1617348749948)(Pictures\6.png)]

subject：主体，可以是用户也可以是程序，主体要访问系统，系统需要对主体进行认证、授权。

securityManager：安全管理器，主体进行认证和授权都是通过securityManager进行。

authenticator：认证器，主体进行认证最终通过authenticator进行的。

authorizer：授权器，主体进行授权最终通过authorizer进行的。

sessionManager：web应用中一般是用web容器对session进行管理，shiro也提供一套session管理的方式。

SessionDao：通过SessionDao管理session数据，针对个性化的session数据存储需要使用sessionDao。

cache Manager：缓存管理器，主要对session和授权数据进行缓存，比如将授权数据通过cacheManager进行缓存管理，和ehcache整合对缓存数据进行管理。

realm：域，领域，相当于数据源，通过realm存取认证、授权相关数据。

注：在realm中存储授权和认证的逻辑。

cryptography：密码管理，提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

比如：md5信息摘要算法。

六、认证流程

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sX5rlRtD-1617348749949)(Pictures\7.png)]

6.1 创建springboot工程并导入依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-web</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.2.3</version>
</dependency>

6.2 在resources目录下创建shiro.ini文件，IEDA需要安装*.ini并重启方可生效

#对用户的配置
[users]
#对用户的用户名和密码的配置
jack=123
tom=456

6.3 创建认证测试类

package com.qf.authentication;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
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;

public class AuthenticationDemo {

    // 用户登陆和退出
    @Test
    public void testLoginAndLogout() {

        // 创建securityManager工厂，通过ini配置文件创建securityManager工厂
        Factory<SecurityManager> factory = new IniSecurityManagerFactory(
                "classpath:shiro.ini");

        // 创建SecurityManager
        SecurityManager securityManager = factory.getInstance();

        // 将securityManager设置当前的运行环境中
        SecurityUtils.setSecurityManager(securityManager);

        // 从SecurityUtils里边创建一个subject
        Subject subject = SecurityUtils.getSubject();

        // 在认证提交前准备token（令牌）
        // 这里的账号和密码 将来是由用户输入进去
        UsernamePasswordToken token = new UsernamePasswordToken("jack", "123");

        // 执行认证提交
        subject.login(token);

        // 是否认证通过
        boolean isAuthenticated = subject.isAuthenticated();

        System.out.println("是否认证通过：" + isAuthenticated);

        // 退出操作
        subject.logout();

        // 是否认证通过
        isAuthenticated = subject.isAuthenticated();

        System.out.println("是否认证通过：" + isAuthenticated);

    }
}

6.4 执行流程

1、通过ini配置文件创建securityManager

2、调用subject.login方法主体提交认证，提交的token

3、securityManager进行认证，securityManager最终由ModularRealmAuthenticator进行认证。

4、ModularRealmAuthenticator调用IniRealm(给realm传入token) 去ini配置文件中查询用户信息

5、IniRealm根据输入的token（UsernamePasswordToken）从 shiro.ini查询用户信息，根据账号查询用户信息

（账号和密码）

​ 如果查询到用户信息，就给ModularRealmAuthenticator返回用户信息（账号和密码）

​ 如果查询不到，就给ModularRealmAuthenticator返回null

6、ModularRealmAuthenticator接收IniRealm返回Authentication认证信息

​ 如果返回的认证信息是null，ModularRealmAuthenticator抛出异常

（org.apache.shiro.authc.UnknownAccountException）

​ 如果返回的认证信息不是null（说明inirealm找到了用户），对IniRealm返回用户密码 （在ini文件中存在）

​ 和 token中的密码 进行对比，如果不一致抛出异常

（org.apache.shiro.authc.IncorrectCredentialsException）

6.5 总结

ModularRealmAuthenticator作用是进行认证，需要调用realm来查询用户信息（在数据库中存在用户信息）并且进行密码对比（认证过程）

realm：需要根据token中的身份信息去查询数据库（入门程序使用ini配置文件），如果查到用户返回认证信息，如果查询不到返回null

七、使用realm认证

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HgE4ieC2-1617348749950)(Pictures\8.png)]

7.1 创建自定义realm

package com.qf.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

public class realmDemo extends AuthorizingRealm {

    private String realmName  = "realmDemo";

    //认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken 
authenticationToken) throws AuthenticationException {
		//从token中取出用户信息
        //用户名，身份信息
        String principal = (String)authenticationToken.getPrincipal();
        System.out.println(principal);
        //密码，凭证
        Object credentials = authenticationToken.getCredentials();
		//类型转化
        String password = new String((char[]) credentials);
        System.out.println(password);

        if("jack".equals(principal) && "123".equals(password)){

            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password,realmName);

            return simpleAuthenticationInfo;
        }

        return null;
    }

    //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }
}

7.2 在resource目录下创建shiro-realm.ini（注意：realm路径别配置错了）

[main]
#自定义realm
realmDemo=com.qf.realm.realmDemo
#将realm设置到securityManager
securityManager.realms=$realmDemo

7.3 在AuthenticationDemo类中添加方法进行测试

// 自定义realm
@Test
public void testRealmDemo() {

    // 创建securityManager工厂，通过ini配置文件创建securityManager工厂
    Factory<SecurityManager> factory = new IniSecurityManagerFactory(
            "classpath:shiro-realm.ini");

    // 创建SecurityManager
    SecurityManager securityManager = factory.getInstance();

    // 将securityManager设置当前的运行环境中
    SecurityUtils.setSecurityManager(securityManager);

    // 从SecurityUtils里边创建一个subject
    Subject subject = SecurityUtils.getSubject();

    // 在认证提交前准备token（令牌）
    // 这里的账号和密码 将来是由用户输入进去
    UsernamePasswordToken token = new UsernamePasswordToken("jack", "123");

    try {
        // 执行认证提交
        subject.login(token);
    } catch (AuthenticationException e) {
        e.printStackTrace();
    }

    // 是否认证通过
    boolean isAuthenticated = subject.isAuthenticated();

    System.out.println("是否认证通过：" + isAuthenticated);
}

访问controller测试即可

八、MD5加密

---

通常需要对密码 进行散列，常用的有MD5、SHA，

对MD5密码，如果知道散列后的值可以通过穷举算法，得到md5密码对应的明文（指加密前的密码）。

建议对MD5进行散列时加salt（盐），进行加密相当于对原始密码+盐进行散列。

正常使用时散列方法：

在程序中对原始密码+盐进行散列，将散列值存储到数据库中，并且还要将盐也要存储在数据库中。

如果进行密码对比时，使用相同方法，将原始密码+盐进行散列，进行比对。

8.1.创建MD5Demo测试类，进行测试

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

public class MD5Demo {

	public static void main(String[] args) {
		// 原始 密码
		String password = "123";
		// 盐
		String salt = "abcde";
		// 散列次数
		int hashIterations = 2;
		// 上边散列1次：7bc6c31880aeda581aa34e218af25753
		// 上边散列2次：6585096f3f6735025449cfb351c8cff9

		// 第一种方式
		// 构造方法中：
		// 第一个参数：明文，原始密码
		// 第二个参数：盐，通过使用随机数
		// 第三个参数：散列的次数，比如散列两次，相当 于md5(md5(''))
		Md5Hash md5Hash = new Md5Hash(password, salt, hashIterations);

		String password_md5 = md5Hash.toString();
		System.out.println(password_md5);

		// 第二种方式
		// 第一个参数：散列算法
		SimpleHash simpleHash = new SimpleHash("md5", password, salt,
				hashIterations);
		System.out.println(simpleHash.toString());

	}
}

8.2在AuthenticationDemo类中添加方法进行测试

//测试MD5
@Test
public void testMD5() {

    // 创建securityManager工厂，通过ini配置文件创建securityManager工厂
    Factory<SecurityManager> factory =
            new IniSecurityManagerFactory("classpath:shiro-realm-md5.ini");

    // 创建SecurityManager
    SecurityManager securityManager = factory.getInstance();

    // 将securityManager设置当前的运行环境中
    SecurityUtils.setSecurityManager(securityManager);

    // 从SecurityUtils里边创建一个subject
    Subject subject = SecurityUtils.getSubject();

    // 在认证提交前准备token（令牌）
    // 这里的账号和密码 将来是由用户输入进去
    UsernamePasswordToken token = new UsernamePasswordToken("jack", "123");

    try {
        // 执行认证提交
        subject.login(token);
    } catch (AuthenticationException e) {
        e.printStackTrace();

    }

    // 是否认证通过
    boolean isAuthenticated = subject.isAuthenticated();

    System.out.println("是否认证通过：" + isAuthenticated);

}

8.3创建shiro-realm-md5.ini

[main]
#自定义realm
realmDemo=com.qf.realm.realmDemoMD5
#将realm设置到securityManager
securityManager.realms=$realmDemo

8.4创建realmMD5

package com.qf.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

public class realmDemoMD5 extends AuthorizingRealm {

    private String realmName  = "realmDemoMD5";

    //认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //用户名
        String principal = (String)authenticationToken.getPrincipal();
        //System.out.println(principal);

        //密码
        Object credentials = authenticationToken.getCredentials();
        String password = new String((char[]) credentials);
        System.out.println(password);
        
        Md5Hash md5Hash = new Md5Hash(password, "abcde", 2);
        String password_md5 = md5Hash.toString();
        System.out.println(password_md5);
        //从数据库查出来的密码
        String dbpassword = "6585096f3f6735025449cfb351c8cff9";

        if("jack".equals(principal) &&password_md5.equals(dbpassword)){

            SimpleAuthenticationInfo 
simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password,realmName);

            return simpleAuthenticationInfo;
        }

        return null;
    }

    //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }
}

九、授权流程

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-og2TdkXq-1617348749951)(Pictures\9.png)]

9.1创建shiro-permission.ini（shiro-permission.ini里边的内容相当于在数据库）

#用户
[users]
#用户jack的密码是123，此用户具有role1和role2两个角色
jack=123,role1,role2
tom=456,role2

#权限
[roles]
#角色role1对资源user拥有create、update权限
role1=user:create,user:update
#角色role2对资源user拥有create、delete权限
role2=user:create,user:delete
#角色role3对资源user拥有query权限
role3=user:query

9.2创建AuthorizationDemo

package com.qf.authorization;

import java.util.Arrays;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
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;

public class AuthorizationDemo {

	// 角色授权、资源授权测试
	@Test
	public void testAuthorization() {

		// 创建SecurityManager工厂
		Factory<SecurityManager> factory = new IniSecurityManagerFactory(
				"classpath:shiro-permission.ini");

		// 创建SecurityManager
		SecurityManager securityManager = factory.getInstance();

		// 将SecurityManager设置到系统运行环境，和spring后将SecurityManager配置spring容器中，一般单例管理
		SecurityUtils.setSecurityManager(securityManager);

		// 创建subject
		Subject subject = SecurityUtils.getSubject();

		// 创建token令牌
		UsernamePasswordToken token = new UsernamePasswordToken("jack", "123");

		//认证
        subject.login(token);
        //是否认证成功
        boolean authenticated = subject.isAuthenticated();
        System.out.println("是否认证成功："+authenticated);

		//--------认证通过之后进行授权----------

		//基于角色的授权 
        //单个角色判断
        boolean role1 = subject.hasRole("role1");
        System.out.println("role1："+role1);
        //多个角色判断
        boolean allRoles = subject.hasAllRoles(Arrays.asList("role1", "role2"));
        System.out.println("role1 + role2："+allRoles);

        //subject.checkRole("role3");//检查是否有当前角色

		//基于资源的授权
        //单个权限判断
        boolean permitted = subject.isPermitted("user:create");
        System.out.println("user:create："+permitted);
        //多个权限判断
        boolean permittedAll = subject.isPermittedAll("user:create", "user:update");
        System.out.println("user:create + user:update："+permittedAll);

        //subject.checkPermissions("user:query", "user:add");

	}
}

十、使用realm授权

---

需求

上边的程序通过shiro-permission.ini对权限信息进行静态配置，实际开发中从数据库中获取权限数据。就需要自定义realm，由realm从数据库查询权限数据，realm会根据用户身份查询权限数据，将权限数据返回给authorizer（授权器）。

10.1修改之前realmDemo.java中的doGetAuthorizationInfo方法

//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

    // 从 principals获取主身份信息
    // 将getPrimaryPrincipal方法返回值转为真实身份类型（在上边的doGetAuthenticationInfo认证通过填充到SimpleAuthenticationInfo中身份类型）
    String primaryPrincipal = (String)principalCollection.getPrimaryPrincipal();
    System.out.println("primaryPrincipal："+primaryPrincipal);

    // 根据身份信息获取权限信息
    // 连接数据库...
    // 模拟从数据库获取到数据

    //把数据库中查到的角色放进集合中
    ArrayList<String> roles = new ArrayList<>();
    roles.add("role1");
    roles.add("role2");

    //把数据库中查到的资源放进集合中
    HashSet<String> permissions = new HashSet<>();
    permissions.add("user:add");
    permissions.add("user:update");

    //查到权限数据，返回授权信息（包括以上的角色或者资源）
    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
    //通过角色授权
    //simpleAuthorizationInfo.addRoles(roles);
    //通过资源授权
    simpleAuthorizationInfo.addStringPermissions(permissions);

    return simpleAuthorizationInfo;
}

10.2创建shiro-realm.ini文件，配置自定义的realm，将realm设置到securityManager中，因为之前已经配置过，该步骤可以省略

10.3在AuthorizationDemo中添加方法进行测试

//授权
@Test
public void testAuthorization(){

    //准备环境
    IniSecurityManagerFactory iniSecurityManagerFactory =
        new IniSecurityManagerFactory("classpath:shiro-realm.ini");

    SecurityManager securityManager = iniSecurityManagerFactory.getInstance();

    SecurityUtils.setSecurityManager(securityManager);
    //获取主体
    Subject subject = SecurityUtils.getSubject();

    UsernamePasswordToken token = new UsernamePasswordToken("jack","123");
    //认证
    subject.login(token);
    //是否认证成功
    boolean authenticated = subject.isAuthenticated();
    System.out.println("是否认证成功："+authenticated);

    //--------认证通过之后进行授权----------
    //单个角色判断
    boolean role1 = subject.hasRole("role1");
    System.out.println("role1："+role1);
    //多个角色判断
    boolean allRoles = subject.hasAllRoles(Arrays.asList("role1", "role2"));
    System.out.println("role1 + role2："+allRoles);

    //subject.checkRole("role3");//检查是否有当前角色

    //-------判断权限--------
    //单个权限判断
    boolean permitted = subject.isPermitted("user:create");
    System.out.println("user:create："+permitted);
    //多个权限判断
    boolean permittedAll = subject.isPermittedAll("user:create", "user:update");
    System.out.println("user:create + user:update："+permittedAll);

    //subject.checkPermissions("user:query", "user:add");
}

10.4 授权流程

1、对subject进行授权，调用方法isPermitted（“permission串”）
2、SecurityManager执行授权，通过ModularRealmAuthorizer执行授权
3、ModularRealmAuthorizer执行realm（自定义的Realm）从数据库查询权限数据，调用realm的doGetAuthorizationInfo授权方法
4、realm从数据库查询权限数据，返回ModularRealmAuthorizer
5、ModularRealmAuthorizer调用PermissionResolver进行权限串比对
6、如果比对后，isPermitted中"permission串"在realm查询到权限数据中，说明用户访问permission串有权限，否则 没有权限，抛出异常。

十一、SpringBoot整合Shiro

---

11.1导入依赖

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

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

11.2配置application.properties

#配置mysql
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql:///java2002?serverTimezone=Asia/Shanghai
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#连接池
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#mybatis
#扫描mapper.xml文件
mybatis.mapper-locations=classpath:mapper/*.xml
#sql语句显示到控制台
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#配置thymeleaf
spring.thymeleaf.prefix=classpath:/templates
spring.thymeleaf.suffix=.html
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.cache=false
spring.thymeleaf.mode=HTML

#去除访问路径后携带sessionid
server.servlet.session.tracking-modes=cookie

11.3编写ShiroRealm

package com.qf.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

public class ShiroRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

11.4编写ShiroConfig

package com.qf.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.qf.realm.ShiroRealm;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    public ShiroRealm getShiroRealm(){
        return new ShiroRealm();
    }

    //安全管理对象
    @Bean
    public SecurityManager getSecurityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(getShiroRealm());
        return securityManager;
    }


    //Shiro过滤器配置
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(SecurityManager securityManager){
        //创建Shiro工厂对象
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //未认证访问页面
        shiroFilterFactoryBean.setLoginUrl("/toLogin");
        //认证成功跳转页面（一般不设置，默认登录成功跳转当前页面）
        //shiroFilterFactoryBean.setSuccessUrl("/index");
        //未授权访问页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/refuse");
        //通过map配置访问流程（顺序很重要）
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        //配置静态资源
        map.put("/js/**","anon");
        map.put("/css/**","anon");
        map.put("/jquery/**","anon");
        map.put("/layui/**","anon");
        //配置login页面
        map.put("/login","anon");
        //配置logout退出
        //map.put("/logout","logout");
        //配置授权
        //map.put("/delete","perms[user:delete]");
        //map.put("/select","perms[user:select]");

        //user设置记住我（二次登录不做认证操作）
        //map.put("/index","user");

        map.put("/**","authc");//该路径认证后才能访问
        //map.put("/**","anon");//所有路径都可以匿名访问

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

}

过滤器简称	对应的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

anon：admins/**=anon 没有参数，表示可以匿名使用。
authc：/admins/user/**=authc表示需要认证(登录)才能使用，FormAuthenticationFilter是表单认证，没有参数 

roles：/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。

perms：/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。

rest：/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method] ,其中method为post，get，delete等。

port：/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal：//serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString是你访问的url里的？后面的参数。

authcBasic：例如/admins/user/**=authcBasic没有参数表示httpBasic认证

ssl：/admins/user/**=ssl没有参数，表示安全的url请求，协议为https

user：/admins/user/**=user没有参数表示必须存在用户, 身份认证通过或通过记住我认证通过的可以访问，当登入操作时不做检查

anon，authcBasic，authc，user是认证过滤器

perms，roles，ssl，rest，port是授权过滤器

11.5创建controller

package com.qf.controller;


import org.apache.shiro.SecurityUtils;
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.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {

    @RequestMapping("toLogin")
    public String toLgoin(){
        System.out.println("toLogin");
        return "/login";
    }

    @RequestMapping("login")
    public String login(){
        System.out.println("login");
        return "/login";
    }

    @RequestMapping("refuse")
    public String refuse(){
        System.out.println("refuse");
        return "/refuse";
    }

    @RequestMapping("index")
    public String index(){
        System.out.println("index");
        return "/index";
    }

    @RequestMapping("add")
    public String add(){
        System.out.println("add");
        return "/add";
    }

    @RequestMapping("select")
    public String select(){
        System.out.println("select");
        return "/select";
    }

    @RequestMapping("delete")
    public String delete(){
        System.out.println("delete");
        return "/delete";
    }

//    @RequestMapping("logout")
//    public String logout(){
//        System.out.println("logout");
//        Subject subject = SecurityUtils.getSubject();
//        subject.logout();
//        return "/login";
//    }
}

启动工程，进行测试

11.6编写对应的login.html页面（以及其他页面）

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<center>
    <form action="login">

        用户名：<input type="text" name="username"><br> <br>
        密码：<input type="password" name="password"><br> <br>

        <input type="submit" value="登录">
    </form>
</center>

</body>
</html>

refuse.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1><font color="red">拒绝访问！！！</font> </h1>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>主页面</h1>

<a href="add">添加用户</a>
<a href="select">查询用户</a>
<a href="delete">删除用户</a>
<a href="update">修改用户</a>
<a href="/logout">退出</a>

</body>
</html>

add.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>添加用户</h1>
</body>
</html>

select.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>查询用户</h1>
</body>
</html>

delete.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>删除用户</h1>
</body>
</html>

11.7实现用户认证，修改UserController中的login方法

@RequestMapping("login")
public String login(String username, String password){
    System.out.println("login");

    Subject subject = SecurityUtils.getSubject();

    UsernamePasswordToken token = new UsernamePasswordToken(username, password);

    subject.login(token);

    boolean authenticated = subject.isAuthenticated();

    if(authenticated){
        return "/index";
    }
    return "/login";
}

11.8修改ShiroRealm中的AuthenticationInfo方法

@Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        //身份信息，用户名
        String principal = (String)token.getPrincipal();
        System.out.println(principal);
        //凭证信息，密码
        String credentials = new String((char[])token.getCredentials());
        System.out.println(credentials);

        //判断
        if("jack".equals(principal) && "123".equals(credentials)){
            return new SimpleAuthenticationInfo(principal,credentials,"ShiroRealm");
        }

        return null;
    }

访问路径进行测试即可！

11.9实现用户授权，在ShiroConfig中的shiroFilter方法中添加被授权的信息

//配置授权
map.put("/delete","perms[user:delete]");
map.put("/select","perms[user:select]");

配置之后重启项目，访问该资源路径时则无法访问，此时需要配置授权信息

11.10修改ShiroRealm中的doGetAuthorizationInfo方法

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

    HashSet<String> set = new HashSet<>();
    set.add("user:select");
    set.add("user:update");

    simpleAuthorizationInfo.addStringPermissions(set);

    return simpleAuthorizationInfo;
}

然后重启项目，再次访问相应授权路径页面

11.11Shiro整合thymleaf标签

<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>

11.12在ShiroConfig中添加该方法

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

11.13修改index.html页面中测试

<!DOCTYPE html>
<html lang="en" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>主页面</h1>

<a href="add">添加用户</a>
<a href="select">查询用户</a>
<a href="delete" shiro:hasPermission="user:delete">删除用户</a>
<a href="update" shiro:hasPermission="user:update">修改用户</a>
<a href="/logout">退出</a>

</body>
</html>

启动工程，再次进行测试即可

11.14实现用户退出（两种方式），在相关index.html页面中添加超链接

<a href="/logout">退出</a>

11.15在ShiroConfig中的shiroFilter方法中添加退出配置（第一种）

//配置退出
map.put("/logout","logout");

11.16在UserController中添加logout方法（第二种）

@RequestMapping("logout")
public String logout(){
    System.out.println("logout");
    Subject subject = SecurityUtils.getSubject();
    subject.logout();
    return "/login";
}

11.17记住我rememberMe，在login.html页面中添加记住我

<input type="checkbox" name="rememberMe">记住我<br> <br>

11.18在UserController中的login方法配置rememberMe参数

@RequestMapping("login")
public String login(String username, String password,boolean rememberMe){
    System.out.println("login");

    Subject subject = SecurityUtils.getSubject();

    UsernamePasswordToken token = new UsernamePasswordToken(username, password,rememberMe);

    subject.login(token);

    boolean authenticated = subject.isAuthenticated();

    if(authenticated){
        return "/index";
    }
    return "/login";
}

11.19在ShiroConfig类中添加相关方法以及代码

package com.qf.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.qf.realm.ShiroRealm;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    @Bean
    public CookieRememberMeManager getCookieRememberMeManager(){

        SimpleCookie simpleCookie = new SimpleCookie("renemberMe");
        simpleCookie.setMaxAge(3600*24*31);

        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(simpleCookie);

        return cookieRememberMeManager;
    }

    public ShiroRealm getShiroRealm(){
        return new ShiroRealm();
    }

    @Bean
    public SecurityManager getSecurityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(getShiroRealm());
        securityManager.setRememberMeManager(getCookieRememberMeManager());
        return securityManager;
    }

    //配置ShiroDialect
    @Bean
    public ShiroDialect getShiroDialect(){
        return new ShiroDialect();
    }

    //shiro过滤器配置
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //未认证访问页面
        shiroFilterFactoryBean.setLoginUrl("/toLogin");
        //认证成功跳转页面（一般不设置，默认登录成功跳转当前页面）
        //shiroFilterFactoryBean.setSuccessUrl("/index");
        //未授权访问页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/refuse");
        //通过map配置访问流程（顺序很重要）
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        //配置静态资源
        map.put("/js/**","anon");
        map.put("/css/**","anon");
        map.put("/jquery/**","anon");
        map.put("/layui/**","anon");
        //配置login页面
        map.put("/login","anon");
        //配置logout退出
        map.put("/logout","logout");
        //配置授权
        map.put("/delete","perms[user:delete]");
        map.put("/select","perms[user:select]");

        //user设置记住我（二次登录不做认证操作）
        map.put("/index","user");

        map.put("/**","authc");//该路径认证后才能访问
        //map.put("/**","anon");//所有路径都可以匿名访问

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

}

rityManager;
}

//配置ShiroDialect
@Bean
public ShiroDialect getShiroDialect(){
    return new ShiroDialect();
}

//shiro过滤器配置
@Bean
public ShiroFilterFactoryBean getShiroFilterFactoryBean(SecurityManager securityManager){
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    //未认证访问页面
    shiroFilterFactoryBean.setLoginUrl("/toLogin");
    //认证成功跳转页面（一般不设置，默认登录成功跳转当前页面）
    //shiroFilterFactoryBean.setSuccessUrl("/index");
    //未授权访问页面
    shiroFilterFactoryBean.setUnauthorizedUrl("/refuse");
    //通过map配置访问流程（顺序很重要）
    LinkedHashMap<String, String> map = new LinkedHashMap<>();
    //配置静态资源
    map.put("/js/**","anon");
    map.put("/css/**","anon");
    map.put("/jquery/**","anon");
    map.put("/layui/**","anon");
    //配置login页面
    map.put("/login","anon");
    //配置logout退出
    map.put("/logout","logout");
    //配置授权
    map.put("/delete","perms[user:delete]");
    map.put("/select","perms[user:select]");

    //user设置记住我（二次登录不做认证操作）
    map.put("/index","user");

    map.put("/**","authc");//该路径认证后才能访问
    //map.put("/**","anon");//所有路径都可以匿名访问

    shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
    return shiroFilterFactoryBean;
}

}

>登录页面勾选 记住我 进行测试