SpringBoot完整版（六）- Shiro

一、概述

1.1 简介

Apache Shiro是一个强大且易用的Java安全（权限）框架

可以完成身份验证、授权、密码和会话管理

Shiro 不仅可以用在 JavaSE 环境中，也可以用在 JavaEE 环境中

官网： http://shiro.apache.org/

1.2 功能

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

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

Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web支持，可以非常容易的集成到Web环境；

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

Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

1.3 Shiro架构（外部）

应用代码直接交互的对象是Subject，也就是说Shiro的对外API核心就是Subject；其每个API的含义：

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；

SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；

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

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

1. 应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；

2. 我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。

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

1.4 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来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）；

SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；

CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能

Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的

1.5 认证流程

用户 提交 身份信息、凭证信息 封装成 令牌 交由 安全管理器 认证

二、快速入门

2.1 拷贝案例

查看官方文档：http://shiro.apache.org/tutorial.html
官方的quickstart：https://github.com/apache/shiro/tree/master/samples/quickstart

1. 新建一个 Maven 工程，删除其 src 目录，将其作为父工程

2. 在父工程中新建一个 Maven 模块
   

3. 复制快速入门案例 POM.xml 文件中的依赖 （版本号自选）

<dependencies>
        <dependency>
            <groupId>org.apache.shirogroupId>
            <artifactId>shiro-coreartifactId>
            <version>1.4.1version>
        dependency>

        
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>jcl-over-slf4jartifactId>
            <version>1.7.29version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.7.29version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
    dependencies>

4. 把快速入门案例中的 resource 下的log4j.properties 复制下来

log4j.rootLogger=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n

# General Apache libraries
log4j.logger.org.apache=WARN

# Spring
log4j.logger.org.springframework=WARN

# Default Shiro logging
log4j.logger.org.apache.shiro=INFO

# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

5. 复制一下 shiro.ini 文件

[users]
# user 'root' with password 'secret' and the 'admin' role
root = secret, admin
# user 'guest' with the password 'guest' and the 'guest' role
guest = guest, guest
# user 'presidentskroob' with password '12345' ("That's the same combination on
# my luggage!!!" ;)), and role 'president'
presidentskroob = 12345, president
# user 'darkhelmet' with password 'ludicrousspeed' and roles 'darklord' and 'schwartz'
darkhelmet = ludicrousspeed, darklord, schwartz
# user 'lonestarr' with password 'vespa' and roles 'goodguy' and 'schwartz'
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# Roles with assigned permissions
# 
# Each line conforms to the format defined in the
# org.apache.shiro.realm.text.TextConfigurationRealm#setRoleDefinitions JavaDoc
# -----------------------------------------------------------------------------
[roles]
# 'admin' role has all permissions, indicated by the wildcard '*'
admin = *
# The 'schwartz' role can do anything (*) with any lightsaber:
schwartz = lightsaber:*
# The 'goodguy' role is allowed to 'drive' (action) the winnebago (type) with
# license plate 'eagle5' (instance specific id)
goodguy = winnebago:drive:eagle5

6. 复制一下 Quickstart.java 文件
   如果有导包的错误，把那两个错误的包删掉，就会自动导对的包了，快速入门案例中用的方法过时了
7. 运行 Quickstart.java，得到结果
   

2.2 分析案例

1. 通过 SecurityUtils 获取当前执行的用户 Subject

Subject currentUser = SecurityUtils.getSubject();

2. 通过 当前用户拿到 Session

Session session = currentUser.getSession();

3. 用 Session 存值取值

        session.setAttribute("someKey", "aValue");
        String value = (String) session.getAttribute("someKey");

4. 判断用户是否被认证

currentUser.isAuthenticated()

5. 执行登录操作

currentUser.login(token);

6. 打印其标识主体

currentUser.getPrincipal()

7. 注销

currentUser.logout();

8. 总览
   

三、SpringBoot 集成 Shiro

3.1 编写配置文件

1. 在刚刚的父项目中新建一个 springboot 模块，导入web，thymeleaf 依赖。

2. 导入 SpringBoot 和 Shiro 整合包的依赖

		
		<dependency>
			<groupId>org.apache.shirogroupId>
			<artifactId>shiro-spring-boot-web-starterartifactId>
			<version>1.6.0version>
		dependency>

下面是编写配置文件 Shiro 三大要素

• subject -> ShiroFilterFactoryBean
• securityManager -> DefaultWebSecurityManager
• realm
• 实际操作中对象创建的顺序 ： realm -> securityManager -> subject

3. 编写自定义的 realm ，需要继承 AuthorizingRealm

package com.example.config;

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;

//自定义的 Realm
public class UserRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //打印一个提示
        System.out.println("执行了授权方法");
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //打印一个提示
        System.out.println("执行了认证方法");
        return null;
    }
}

4. 新建一个 ShiroConfig配置文件

• 按照上面说的创建过程来写 1、创建 Realm

    //1. realm
    //让 spring 托管自定义的 realm 类
    @Bean
    public UserRealm userRealm() {
        return new UserRealm();
    }

• 2、创建 securityManager

    //2. securityManager -> DefaultWebSecurityManager
    // @Qualifier("userRealm") 指定 Bean 的名字为 userRealm
    // spring 默认的 BeanName 就是方法名
    // name 属性 指定 BeanName
    @Bean(name = "SecurityManager")
    public DefaultWebSecurityManager getDefaultWebSecurity(@Qualifier("userRealm") UserRealm userRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //需要关联自定义的 Realm，通过参数把 Realm 对象传递过来
        securityManager.setRealm(userRealm);
        return securityManager;
    }

• 3、创建 subject

    //3. subject -> ShiroFilterFactoryBean
    // @Qualifier("securityManager") 指定 Bean 的名字为 securityManager
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("SecurityManager") DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
        //设置安全管理器
        //需要关联 securityManager ，通过参数把 securityManager 对象传递过来
        subject.setSecurityManager(securityManager);
        return subject;
    }

完整代码

package com.example.config;

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;

@Configuration
public class ShiroConfig {
    //3. subject -> ShiroFilterFactoryBean
    // @Qualifier("securityManager") 指定 Bean 的名字为 securityManager
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("SecurityManager") DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
        //设置安全管理器
        //需要关联 securityManager ，通过参数把 securityManager 对象传递过来
        subject.setSecurityManager(securityManager);
        return subject;
    }

    //2. securityManager -> DefaultWebSecurityManager
    // @Qualifier("userRealm") 指定 Bean 的名字为 userRealm
    // spring 默认的 BeanName 就是方法名
    // name 属性 指定 BeanName
    @Bean(name = "SecurityManager")
    public DefaultWebSecurityManager getDefaultWebSecurity(@Qualifier("userRealm") UserRealm userRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //需要关联自定义的 Realm，通过参数把 Realm 对象传递过来
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    //1. realm
    //让 spring 托管自定义的 realm 类
    @Bean
    public UserRealm userRealm() {
        return new UserRealm();
    }
}

3.2 搭建简单测试环境

1. 新建一个首页
   首页上有两个链接，一个增加用户，一个删除用户

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>

<h1>首页h1>

<p th:text="${msg}">p>

<hr>

<a th:href="@{/user/add}">adda> |  <a th:href="@{/user/update}">updatea>
body>
html>

2. 新建一个增加用户页面

3. 新建一个修改用户页面
   

4. 编写对应的 Controller

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class MyController {

    @RequestMapping({"/index","/"})
    public String toIndex(Model model){
        model.addAttribute("msg","hello shiro");
        return "index";
    }

    @RequestMapping("/user/add")
    public String add(){
        return "user/add";
    }

    @RequestMapping("/user/update")
    public String update(){
        return "user/update";
    }
}

3.3 使用

1. 登录拦截

添加登录页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录title>
head>
<body>
<h1>登录h1>
<form action="">
    <p> <input type="text" name="username">p>
    <p> <input type="text" name="password">p>
    <p> <input type="submit">p>
form>

body>
html>

添加controller

    @RequestMapping("/toLogin")
    public String toLogin(){
        return "login";
    }

在上面的 getShiroFilterFactoryBean 方法中加上需要拦截的登录请求

    //3. subject -> ShiroFilterFactoryBean
    // @Qualifier("securityManager") 指定 Bean 的名字为 securityManager
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("SecurityManager") DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
        //设置安全管理器
        //需要关联 securityManager ，通过参数把 securityManager 对象传递过来
        subject.setSecurityManager(securityManager);

        //添加 Shiro 的内置过滤器=======================
        /*
            anon : 无需认证，就可以访问
            authc : 必须认证，才能访问
            user : 必须拥有 “记住我”功能才能用
            perms : 拥有对某个资源的权限才能访问
            role : 拥有某个角色权限才能访问
         */
        Map<String, String> map = new LinkedHashMap<>();
        // 设置 /user/add 这个请求,只有认证过才能访问
        // map.put("/user/add","authc");
        // map.put("/user/update","authc");
        // 设置 /user/ 下面的所有请求,只有认证过才能访问
        map.put("/user/*","authc");
        subject.setFilterChainDefinitionMap(map);
        // 设置登录的请求
        subject.setLoginUrl("/toLogin");
        //============================================
        return subject;
    }

测试
点击 add 链接，不会跳到 add 页面，而是跳到登录页，拦截成功

2. 用户认证

1、在 Controller 中写一个登录的控制器

//登录的方法
    @RequestMapping("/login")
    public String login(String username, String password, Model model) {
        //获取当前用户
        Subject subject = SecurityUtils.getSubject();
        //没有认证过
        //封装用户的登录数据,获得令牌
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);

        //登录 及 异常处理
        try {
            //用户登录
            subject.login(token);
            return "index";
        } catch (UnknownAccountException uae) {
            //如果用户名不存在
            System.out.println("用户名不存在");
            model.addAttribute("exception", "用户名不存在");
            return "login";
        } catch (IncorrectCredentialsException ice) {
            //如果密码错误
            System.out.println("密码错误");
            model.addAttribute("exception", "密码错误");
            return "login";
        }
    }

修改前端代码（login.html）

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>登录title>
head>
<body>
<h1>登录h1>

<p th:text="${exception}" style="color: red">p>
<form th:action="@{/login}">
    <p> <input type="text" name="username">p>
    <p> <input type="text" name="password">p>
    <p> <input type="submit">p>
form>

body>
html>

2、重启，测试


成功

并且可以看出，是先执行了 自定义的 UserRealm 中的 AuthenticationInfo 方法，再执行了，登录的相关操作

下面去自定义的 UserRealm 中的 AuthenticationInfo 方法中去获取用户信息

3、修改 UserRealm 中的 AuthenticationInfo

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //打印一个提示
        System.out.println("执行了认证方法");
        // 用户名密码(暂时先自定义一个做测试)
        String name = "root";
        String password = "123456";

        //通过参数获取登录的控制器中生成的 令牌
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //用户名认证
        if (!token.getUsername().equals(name)){
            // return null 就表示控制器中抛出的相关异常
            return null;
        }
        //密码认证， Shiro 自己做，为了避免和密码的接触
        //最后返回一个 AuthenticationInfo 接口的实现类，这里选择 SimpleAuthenticationInfo
        // 三个参数：获取当前用户的认证 ； 密码 ； 认证名
        return new SimpleAuthenticationInfo("", password, "");
    }

4、测试
输入错误的密码

输入正确的密码
登录成功，且可以访问 那两个页面

3. 退出登录

在控制器中添加一个退出登录的方法

//退出登录

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

测试：退出成功！

四、Shiro 整合 Mybatis

4.1 配置环境

1. 导入相关依赖

	<dependency>
		<groupId>mysqlgroupId>
		<artifactId>mysql-connector-javaartifactId>
	dependency>
	
	<dependency>
		<groupId>com.alibabagroupId>
		<artifactId>druidartifactId>
		<version>1.1.21version>
	dependency>
	
	<dependency>
		<groupId>log4jgroupId>
		<artifactId>log4jartifactId>
		<version>1.2.17version>
	dependency>
	
	<dependency>
		<groupId>org.mybatis.spring.bootgroupId>
		<artifactId>mybatis-spring-boot-starterartifactId>
		<version>2.1.3version>
	dependency>
	
	<dependency>
		<groupId>org.projectlombokgroupId>
		<artifactId>lombokartifactId>
		<version>1.18.12version>
	dependency>

2. 编写配置文件 application.yml 中配置数据源

spring:
  datasource:
    username: root
    password: root
    #?serverTimezone=UTC解决时区的报错
    url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

    #Spring Boot 默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入
    #如果允许时报错  java.lang.ClassNotFoundException: org.apache.log4j.Priority
    #则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3. 新建三个包
   com.example.pojo
   com.example.mapper
   resources.mapper
4. 在 application.properties 中配置 mybatis
   实体类包的别名
   Mapper 文件地址

mybatis.mapper-locations: classpath:mapper/*.xml
mybatis.type-aliases-package: com.example.pojo

5. 编写实体类

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

6. 编写 Mapper 接口

@Mapper
@Repository
public interface UserMapper {
    @Select("select * from user")
    List<User> getAllUser();

     @Select("select * from user where name=#{name}")
	User getUserByName( @Param("name") String name);

    @Insert("insert into user (id, name, pwd) values (#{id},#{name},#{pwd})")
    int addUser(User user);

    @Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
    int updateUser(User user);

    @Delete("delete from user where id=#{id}")
    int deleteUser( @Param("id")int id);
}

7. 编写 Mapper.xml
   基本操作都用注解做了，这里就放空

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
mapper>

8. 编写 Service

public interface UserService {
    List<User> getAllUser();
    User getUserByName(String name);
    void addUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

9. 编写实现类

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    UserMapper userMapper;

    @Override
    public List<User> getAllUser() {
        return userMapper.getAllUser();
    }

    @Override
    public User getUserByName(String name) {
        return userMapper.getUserByName(name);
    }

    @Override
    public void addUser(User user) {
        int rows = userMapper.addUser(user);
        if (rows > 0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }
    }

    @Override
    public void updateUser(User user) {
        int rows = userMapper.updateUser(user);
        if (rows > 0){
            System.out.println("修改成功");
        }else {
            System.out.println("修改失败");
        }
    }

    @Override
    public void deleteUser(int id) {
        int rows = userMapper.deleteUser(id);
        if (rows > 0){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
    }
}

10. 测试

    @Autowired
    UserServiceImpl userService;

    @Test
    void contextLoads() {
        System.out.println(userService.getUserByName("张三"));
    }

4.2 Shiro + Mybatis 结合使用

1. 修改 UserRealm
   
   修改后：

package com.example.config;

import com.example.pojo.User;
import com.example.service.UserServiceImpl;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

//自定义的 Realm
public class UserRealm extends AuthorizingRealm {
    @Autowired
    UserServiceImpl userService;

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //打印一个提示
        System.out.println("执行了授权方法");
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //打印一个提示
        System.out.println("执行了认证方法");
        //通过参数获取登录的控制器中生成的 令牌
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        // 用户名密码(暂时先自定义一个做测试)
        User user = userService.getUserByName(token.getUsername());
        if (user != null) {
            //密码认证， Shiro 自己做，为了避免和密码的接触
            //最后返回一个 AuthenticationInfo 接口的实现类，这里选择 SimpleAuthenticationInfo
            // 三个参数：获取当前用户的认证 ； 密码 ； 认证名
            return new SimpleAuthenticationInfo("", user.getPwd(), "");
        } else {
            // return null 就抛出没有该用户的异常
            return null;
        }
    }
}

2. 使用数据库中的数据，测试成功！

五、Shiro 请求授权实现

5.1 设置权限

在ShiroConfig进行过滤的时候加一些操作：

运行测试，登录后点击add

添加未授权控制

    @RequestMapping("/noauth")
    @ResponseBody
    public String unauthorized(){
        return "未经授权无法访问此页面！";
    }

重新启动项目

5.2 授予权限

在 UserRealm 中添加授权

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //打印一个提示
        System.out.println("执行了授权方法");

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addStringPermission("user:add");

        return info;
    }

重新启动测试，成功进入。

5.3 数据库操作

修改数据库，添加 perms 字段

修改 pojo 中的 user 类

package com.example.pojo;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
    private String perms;
}

修改 UserRealm

        //拿到当前登录的对象
        Subject subject = SecurityUtils.getSubject();
        //拿到user对象
        User currentUser = (User) subject.getPrincipal();

        //设置当前用户的权限
        info.addStringPermission(currentUser.getPerms());

六、Shiro 整合 Thymeleaf

6.1 环境搭建

1. 引入一个 Shiro 和 Thymeleaf 整合的依赖

<dependency>
    <groupId>com.github.theborakompanionigroupId>
    <artifactId>thymeleaf-extras-shiroartifactId>
    <version>2.0.0version>
dependency>

2. 在所有页面中引入 Shiro 和 thymeleaf 的支持

<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">

3. 修改 index.html 页面

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>

<h1>首页h1>

<div th:if="${session.loginUser==null}">
   <a th:href="@{/toLogin}">登录a>
div>

<p th:text="${msg}">p>

<hr>

<div shiro:hasPermission="user:add">
    <a th:href="@{/user/add}">adda>
div>

<div shiro:hasPermission="user:update">
    <a th:href="@{/user/update}">updatea>
div>

body>
html>

4. 添加session

        Subject currentSubject = SecurityUtils.getSubject();
        Session session = currentSubject.getSession();
        session.setAttribute("loginUser",user);

6.2 使用

<--! guest标签,用户没有身份验证时显示相应信息，即游客访问信息。-->
　　<shiro:guest>
　　shiro:guest>
<--! user标签，用户已经身份验证/记住我登录后显示相应的信息。-->
　　<shiro:user>　　
　　shiro:user>
　　

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

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

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

<--! hasRole标签，如果当前Subject有角色将显示body体内容。
 -->
　　<shiro:hasRole name="admin">　　
　　shiro:hasRole>
<--!  方法2 -->
<div shiro:hasRole="admin">
div>
　　
<--! hasAnyRoles标签,如果当前Subject有任意一个角色（或的关系）将显示body体内容。 -->
　　<shiro:hasAnyRoles name="admin,user">
　　　
　　shiro:hasAnyRoles>
<--！ 方法2 -->
<div shiro:hasAnyRoles="admin">
div>

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

<--! hasPermission标签:是否   如果当前Subject有权限将显示body体内容 -->
　　<shiro:hasPermission name="user:create">　　
　　shiro:hasPermission>

6.3 方言配置

如果依赖和支持的标签都导入了，Shiro 标签还是不生效
就需要在 Shiro 的配置文件（ShiroConfig）中加上方言配置

	// Shiro 在 html 页面上方言配置
    @Bean(name="shiroDialect")
    public ShiroDialect shiroDialect(){
        return new ShiroDialect();
    }