二十二、shiro安全框架基础

一、简介

1. shiro简介

• Apache Shiro 是 Java 的一个安全（权限）框架。
• Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE 环境，也可以用在 JavaEE 环境。
• Shiro 可以完成：认证、授权、加密、会话管理、与Web 集成、缓存等。

官网地址：https://shiro.apache.org/

2. 为什么要用shiro

自·2003· 年以来，框架格局发生了相当大的变化，因此今天仍然有很多系统在使用Shiro。这与 Shiro 的特性密不可分。
易于使用: 使用 Shiro 构建系统安全框架非常简单。就算第一次接触也可以快速掌握。
全面:Shiro 包含系统安全框架需要的功能，满足安全需求的“一站式服务”。“
灵活:Shiro 可以在任何应用程序环境中工作。虽然它可以在· Web、EJB和 IOC·环中工作，但不需要依赖它们。Shiro 也没有强制要求任何规范，甚至没有很多依赖项。“
强力支持 Web: Shiro 具有出色的Web应用程序支持，可以基于应用程序URL和Web协议(例如REST创建灵活的安全策略，时还提供一组JSP库来控制页面输出
兼容性强:Shiro 的设计模式使其易于与其他框架和应用程序集成。Shiro· 与Spring、Grails、Wicket、Tapestry、Mule、Apache· Camel、Vaadin· 等框架无缝集成。
社区支持:Shiro 是 Apache 软件基金会的一个开源项目，有完备的社区支持，文档支持。如果需要，像 Katasoft 这样的商业公司也会提供专业的支持和服务。

3. Shiro 与 SpringSecurity 的对比

• SpringSecurity基于 Spring 开发，项目若使用Spring 作为基础，配合SpringSecurity做权限更加方便，而Shiro 需要和 Spring 进行整合开发;
• SpringSecurity功能比 Shiro 更加丰富些，例如安全维护方面;
• SpringSecurity社区资源相对比 Shiro更加丰富
• Shiro 的配置和使用比较简单，SpringSecurity上手复杂些;e
• Shiro 依赖性低，不需要任何框架和容器，可以独立运行。SpringSecurity依赖Spring 容器;
• shiro 不仅仅可以使用在 web 中，它可以工作在任何应用环境中。在集群会话时 Shiro最重要的一个好处或许就是它的会话是独立于容器的。

4. 功能简介

• Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
• Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用
  户是否能进行什么操作，如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户
  对某个资源是否具有某个权限；
• Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有
  信息都在会话中；会话可以是普通 JavaSE 环境，也可以是 Web 环境的；
• Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
• Web Support：Web 支持，可以非常容易的集成到Web 环境；
• Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可
  以提高效率；
• Concurrency：Shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能
  把权限自动传播过去；
• Testing：提供测试支持；
• Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
• Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登
  录了

5. Shiro 架构

⑴ Shiro外部来看

从外部来看Shiro ，即从应用程序角度的来观察如何使用 Shiro 完成工作：

• Subject：应用代码直接交互的对象是 Subject，也就是说 Shiro 的对外API 核心就是 Subject。Subject 代表了当前“用户”， 这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；与 Subject 的所有交互都会委托给 SecurityManager；Subject 其实是一个门面，SecurityManager 才是实际的执行者；
• SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager 交互；且其管理着所有 Subject；可以看出它是 Shiro的核心，它负责与 Shiro 的其他组件进行交互，它相当于SpringMVC 中DispatcherServlet 的角色
• Realm：Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource

⑵ Shiro内部来看

• Subject：任何可以与应用交互的“用户”；
• SecurityManager ：相当于SpringMVC 中的 DispatcherServlet；是 Shiro 的心脏；所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证、授权、会话及缓存的管理。
• Authenticator：负责 Subject 认证，是一个扩展点，可以自定义实现；可以使用认证策略（Authentication Strategy），即什么情况下算用户认证通过了；
• Authorizer：授权器、即访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
• Realm：可以有 1 个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC 实现，也可以是内存实现等等；由用户提供；所以一般在应用中都需要实现自己的 Realm；
• SessionManager：管理 Session 生命周期的组件；而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境
• CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少改变，放到缓存中后可以提高访问的性能
• Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密/解密。

二、shiro基本使用

1. 环境准备

⑴ shiro不依赖容器，直接创建maven工程即可

⑵ 添加依赖

<dependencies>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.9.0</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

2. INI文件

Shiro 获取权限相关信息可以通过数据库获取，也可以通过 ini 配置文件获取。

⑴ 创建ini文件

⑵ 添加相关配置

[users]
zhangsan=z3
lisi=l4

3. 登录认证

⑴ 登录认证相关概念

1） 身份验证:一般需要提供如身份ID等一些标识信息来表明登录者的身份，如提供email，用户名/密码来证明。

2）在shiro中，用户需要提供principals(身份)和credentials (证明)给shiro，从而应用能验证用户身份

3） principals: 身份，即主体的标识属性，可以是任何属性，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/邮箱/手机号。"

4） credentials: 证明/凭证，即只有主体知道的安全值，如密码/数字证书等。

5） 最常见的principals和eredentials组合就是用户名/密码

⑵ 登录认证基本流程

1）收集用户身份/凭证，即如用户名/密码

2）调用 Subiect.login 进行登录，如果失败将得到相应的AuthenticationException异常，根据异常提示用户错误信息， 否则登录成功

3） 创建自定义的Realm类，继承org.apnche,shiro.realmAuthenticatingRenlm类实现doGetAuthenticationInfo()方法

⑶ 登录认证代码实例

创建测试类ShiroRun ，获取认证对象，进行登录认证，如下：

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //2.获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        //3.创建token对象，web应用用户名/密码从页面传递
        AuthenticationToken token = new UsernamePasswordToken("zhangsan1", "z3");
        //4.完成登录
        try{
            subject.login(token);
            System.out.println("登录成功");
        }catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("用户不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误");
        }catch (AuthenticationException ae){
            ae.printStackTrace();
        }

    }
}

效果如下：

⑷ 角色、授权

1） 授权概念

① 授权

也叫访问控刷，即在应用中控制谁访问哪些资源(如访问页面/编辑数据/页面操作等)。在授权中需了解的几个关键对象: 主体(Subject)、资源(Resource)、权限·(Permission)、角色(Role)。

② 主体(Subject)

访问应用的用户，在Shiro 中使用Subject代表该用户。用户只有授权后才允许访问相应的资源。

③ 资源(Resource)

在应用中用户可以访问的URL，比如访问JSP页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。

④ 权限(Permission)

安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如访问用户列表页面查看/新增/修改/删除用户数据(即很多时候都是CRUD(增查改制)式权限控·制)等。权限代表了用户有没有操作某个资源的权利，即反映在某个资源上的操作允不允·许。

⑤ Shiro 支持粗粒度权限(如用户模块的所有权限)和细粒度权限(操作某个用户的权限，即实例级别的)

⑥ 角色(Role):

权限的集合，一般情况下会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如:项目经理、技术总监、CTO、开发工程师等·都是角色，不同的角色拥有一组不同的权限

2）授权方式

① 编程式：通过写if/else授权代码块完成

if(subject.hasRole("admin")){
	//有权限
}else{
	//无权限
}

② 注解式：通过在执行的java方法上放置相应的注解完成，没有权限将抛出相应的异常

@RequiresRoles("admin")
public void hello(){
	//有权限
}

③ JSP/GSP标签：在JSP/GSP页面通过相应的标签完成

<shiro:hasRole name="admin">
	<!--有权限-->
</shiro:hasRole>

3）授权流程

① 首先调用Subject.isPermitted*/hasRole*接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer

② Authorizer是真正的授权者，如果调用如isPermitted("user:view")，其首先会通过PermissionResolver把字符申转换成相应的Permission实例

③ 在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限

④ Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted*/hasRole*会返回true，否则返回false表示授权失败

4）授权实例

① 获取角色信息

○ 给shiro.ini增加角色配置

[users]
zhangsan=z3,role1,role2
lisi=l4

○ 给例子添加代码，通过hasRole()判断用户是否有指定角色

try{
      subject.login(token);
      System.out.println("登录成功");
      //判断角色
      boolean role1 = subject.hasRole("role1");
      System.out.println("是否拥有role1角色="+role1);
  }

完整代码如下：

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //2.获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        //3.创建token对象，web应用用户名/密码从页面传递
        AuthenticationToken token = new UsernamePasswordToken("zhangsan", "z3");
        //4.完成登录
        try{
            subject.login(token);
            System.out.println("登录成功");
            //判断角色
            boolean role1 = subject.hasRole("role1");
            System.out.println("是否拥有role1角色="+role1);
        }catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("用户不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误");
        }catch (AuthenticationException ae){
            ae.printStackTrace();
        }

    }
}

结果如下：

② 判断权限信息

○ 给shiro.ini增加权限配置

[roles]
role1=user:insert,user:select

○ 给例子添加代码，判断用户是否有执行权限

//6.判断权限
boolean permitted = subject.isPermitted("user:insert");
System.out.println("是否拥有user:insert权限="+role1);
//也可以用checkPermission 方法，但没有返回值，没有权限抛AuthenticationException
subject.checkPermission("user:insert");

完整代码如下：

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //2.获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        //3.创建token对象，web应用用户名/密码从页面传递
        AuthenticationToken token = new UsernamePasswordToken("zhangsan", "z3");
        //4.完成登录
        try{
            subject.login(token);
            System.out.println("登录成功");
            //5.判断角色
            boolean role1 = subject.hasRole("role1");
            System.out.println("是否拥有role1角色="+role1);

            //6.判断权限
            boolean permitted = subject.isPermitted("user:insert");
            System.out.println("是否拥有user:insert权限="+role1);

            //也可以用checkPermission 方法，但没有返回值，没有权限抛AuthenticationException
            subject.checkPermission("user:insert");

        }catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("用户不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误");
        }catch (AuthenticationException ae){
            ae.printStackTrace();
        }

    }
}

效果如下：

⑸ shiro加密

实际系统开发中，一些敏感信息需要进行加密，比如说用户的密码。Shiro 内嵌很多常用的加密算法，比如MD5 加密。Shiro 可以很简单的使用信息加密。

1） 使用Shiro进行密码加密

public class ShiroMD5 {
    public static void main(String[] args) {
        //密码明文
        String password = "z3";
        //使用MD5加密
        Md5Hash md5Hash = new Md5Hash(password);
        System.out.println("md5加密="+md5Hash.toHex());
        //带盐的md5加密，盐就是在密码明文后拼接新字符串，然后再进行加密
        Md5Hash md5Salt = new Md5Hash(password, "salt");
        System.out.println("带盐的md5加密="+md5Salt.toHex());
        //为了保证安全，避免被破解还可以多次迭代加密，保证数据安全
        Md5Hash md5Salt3 = new Md5Hash(password, "salt",3);
        System.out.println("md5带盐的三次加密="+md5Salt3.toHex());

        //使用父类SimpleHash进行加密
        SimpleHash simpleHash = new SimpleHash("MD5", password, "salt", 3);
        System.out.println("使用父类SimpleHash带盐的三次加密="+simpleHash.toHex());
    }
}

效果如下：

⑹ Shiro自定义登录认证

Shiro 默认的登录认证是不带加密的,如果想要实现加密认证需要自定义登录认证，自定义 Realm。

1）自定义登录认证

public class MyRealm extends AuthenticatingRealm {
    //自定义登录认证方法，shiro的login方法底层会调用该类的认证方法进行认证
    //需要配置自定义的realm生效，再ini文件中配置，再springboot中配置
    //该方法只是获取进行对比的信息，认证逻辑还是按照shiro底层认证逻辑完成
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取身份信息
        String principal = authenticationToken.getPrincipal().toString();
        //2.获取凭证信息
        String password = new String((char[]) authenticationToken.getCredentials());
        System.out.println("身份信息为："+principal+"&& 凭证信息为："+password);
        //3.获取数据库中存储的用户信息
        if(principal.equals("zhangsan")) {
            //3.1 模拟从数据库中获取存储的加盐3次迭代的密码
            String pwdInfo = "7174f64b13022acd3c56e2781e098a5f";
            //4.创建封装校验逻辑对象，封装数据返回
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    pwdInfo,
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

2）在 shiro.ini 中添加配置信息

md5CredentialsMatcher=org.apache.shiro.authc.credential.Md5CredentialsMatcher
md5CredentialsMatcher.hashIterations=3
myrealm=com.kejizhentan.shiro.MyRealm
myrealm.credentialsMatcher=$md5CredentialsMatcher
securityManager.realms=$myrealm


[users]
zhangsan=7174f64b13022acd3c56e2781e098a5f,role1,role2
lisi=l4

[roles]
role1=user:insert,user:select

3）ShiroRun校验自定义认证

public class ShiroRun {
    public static void main(String[] args) {
        //1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //2.获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        //3.创建token对象，web应用用户名/密码从页面传递
        AuthenticationToken token = new UsernamePasswordToken("zhangsan", "z3");
        //4.完成登录
        try{
            subject.login(token);
            System.out.println("登录成功");

        }catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("用户不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误");
        }catch (AuthenticationException ae){
            ae.printStackTrace();
        }

    }
}

三、Shiro与SpringBoot整合

1. 框架整合

⑴ 创建模块

⑵ 添加依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.1.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-web-starter</artifactId>
        <version>1.9.0</version>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.0.5</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
</dependencies>

⑶ 添加配置文件application.yml

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/*.xml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shirodb?serverTimezone=UTC&characterEncoding=UTF-8&useSSL=false
    password: 123456
    type: com.zaxxer.hikari.HikariDataSource
    username: root
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

shiro:
  loginUrl: /myController/login

⑷ 添加启动类

@SpringBootApplication
@MapperScan("com.kejizhentan.shiro.mapper")
public class ShiroApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShiroApplication.class, args);
    }
}

2. 登录认证实现

访问数据库获取用户信息，实现登录认证

⑴ 后端接口服务实现

1）创建数据库表

CREATE DATABASE IF NOT EXISTS `shirodb` CHARACTER SET utf8mb4;
USE `shirodb`;
CREATE TABLE `user` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT "编号",
  `name` VARCHAR(30) DEFAULT NULL  COMMENT "用户名", 
  `pwd` VARCHAR(50) DEFAULT NULL  COMMENT "密码",
  `rid`  BIGINT(20)  DEFAULT  NULL  COMMENT "角色编号",
  PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=2  DEFAULT CHARSET=utf8 COMMENT="用户表";
INSERT INTO `user` (`id`, `name`, `pwd`, `rid`) VALUES('1','张三','7174f64b13022acd3c56e2781e098a5f',NULL);
INSERT INTO `user` (`id`, `name`, `pwd`, `rid`) VALUES('2','李四','7174f64b13022acd3c56e2781e098a5f',NULL);

2）创建实体User

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

3）创建mapper接口

@Repository
public interface UserMapper extends BaseMapper<User> {
}

4）创建mapper 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">
<mapper namespace="com.kejizhentan.shiro.mapper.UserMapper">

</mapper>

5） 创建service

① 创建接口

public interface UserService extends IService<User> {
    User getUserInfoByName(String name);
}

② 创建实现类

@Service
public class UserServiceImp extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public User getUserInfoByName(String name) {
        QueryWrapper<User> userWrapper = new QueryWrapper<>();
        userWrapper.eq("name",name);
        User user = userMapper.selectOne(userWrapper);
        return user;
    }
}

6）自定义realm

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用业务层获取用户信息（数据库）
        User user = userService.getUserInfoByName(name);
        //3.非空判断，将数据封装返回
        if(user != null){
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

7）编写配置类ShiroConfig

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.返回
        return defaultWebSecurityManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        return definition;
    }
}

8）实现controller

@Controller
@RequestMapping("myController")
public class MyController {

    @GetMapping("userLogin")
    @ResponseBody
    public String userLogin(String name,String pwd){
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd);
        try {
            //3.调用login方法进行登录认证
            subject.login(token);
            System.out.println("登录成功！！！");
            return "登录成功";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败！！！");
            return "登录失败！！！";
        }
    }
}

测试：

浏览器访问http://localhost:8080/myController/userLogin?name=张三&pwd=z3

9）后端的整体构造如下

⑵ 实现前端页面

Shiro整合thymeleaf

1） 确认依赖

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

2）创建登录页面

src/main/resources/templates/login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro登录认证</h1>
    </br>
    <form action="/myController/userLogin">
        <div>用户名：<input type="text" name="name" value=""></div>
        <div>密码：<input type="password" name="pwd" value=""></div>
        <div><input type="submit" value="登录"></div>
    </form>
</body>
</html>

3）添加main.html页面

src/main/resources/templates/main.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证后主页面</h1>
    </br>
    登录用户为：<span th:text="${session.user}"></span>
</body>
</html>

4）修改MyController中的方法

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("/login")
    public String login(){
        return  "login";
    }

    @GetMapping("/userLogin")
    //@ResponseBody
    public String userLogin(String name, String pwd, HttpSession session){
        System.out.println("userLogin被请求了！！！");
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd);
        try {
            //3.调用login方法进行登录认证
            subject.login(token);
            System.out.println("登录成功！！！");
            session.setAttribute("user",token.getPrincipal().toString());
            //return "登录成功";
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败！！！");
            return "登录失败！！！";
        }
    }
}

效果如下：

⑶ 多个realm的认证策略设置

1）多个realm实现原理

当应用程序配置多个 Realm 时，例如: 用户名密码校验、手机号验证码校验等等。Shiro的 ModularRealmAuthenticator 会使用内部的 AuthenticationStrategy 组件判断认证是成功还是失败。
AuthenticationStrategy 是一个无状态的组件，它在身份验证尝试中被询问4次(这4 次交互所需的任何必要的状态将被作为方法参数):

• (1) 在所有 Realm 被调用之前
• (2) 在调用 Realm的getAuthenticationInfo 方法之前
• (3) 在调用 Realm的 getAuthenticationInfo 方法之后
• (4) 在所有 Realm 被调用之后

认证策略的另外一项工作就是聚合所有 Realm 的结果信息封装至一个AuthenticationInfo 实例中，并将此信息返回，以此作为 Subject 的身份信息。

Shiro 中定义了 3 种认证策略的实现:

AuthenticationStrategy.class	描述
AtLeastOneSuccesstulStrateay	只要有一个(或更多)的 Realm 验证成功，那么认证将视为成功
FirstSuccessfulstrategy	第一个 Realm 验证成功，整体认证将视为成功，且后续 Realm 将被忽路
AllSuccessfulstrategy	所有 Realmm 成功，认证才视为成功

ModularRealmAuthenticator 内置的认证策略默认实现是AtleastOneSuccessfulStrategy 方式。可以通过配置修改策略

2）多个realm代码实现

//配置SecurityManager
@Bean
public DefaultWebSecurityManager defaultWebSecurityManager(){
    //1.创建defaultWebSecurityManager对象
    DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
    //2.创建认证对象并设置认证策略
    ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
    modularRealmAuthenticator.setAuthenticationStrategy(new AllSuccessfulStrategy());
    defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator);
    //3.封装多个myRealm集合
    List<Realm> list = new ArrayList<>();
    list.add(myRealm);
    list.add(myRealm2);
    .   .   .
    list.add(myRealmn);
    //4.将myRealm存入到defaultWebSecurityManager对象
    defaultWebSecurityManager.setRealms(list);
    //5.返回
    return defaultWebSecurityManager;
}

⑷ remember me 功能

Shiro·提供了记住我(RememberMe) 的功能，比如访问一些网站时，关闭了浏览器下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问。

1) 基本流程

• (1) 首先在登录页面选中 RememberMe 然后登录成功;如果是浏览器登录，一般会把 RememberMe_的 Cookie 写到客户端并保存下来;e
• (2) 关闭浏览器再重新打开，会发现浏览器还是记住你的
• (3) 访问一般的网页服务器端，仍然知道你是谁，且能正常访问
• (4) 但是，如果我们访问电商平台时，如果要查看我的订单或进行支付时，此时还是需要再进行身份认证的，以确保当前用户还是你。

2) 代码实现

① 修改ShiroConfig类

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        .	.	.	.	.	.
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //6.返回
        return defaultWebSecurityManager;
    }


    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

   .	.	.	.	.	.
}

完整代码如下：

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //6.返回
        return defaultWebSecurityManager;
    }


    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        return definition;
    }
}

② 在MyController类中使用rememberMe

添加@RequestParam(defaultValue = "false")boolean rememberMe参数，设置rememberMe默认为false,传过来的rememberMe设置给UsernamePasswordToken

@Controller
@RequestMapping("myController")
public class MyController {
	.	.	.
    @GetMapping("/userLogin")
    //@ResponseBody
    public String userLogin(String name, String pwd, HttpSession session, @RequestParam(defaultValue = "false")boolean rememberMe){
        .	.	.	
        //2.封装请求数据到token,将rememberMe设置给UsernamePasswordToken
        AuthenticationToken token = new UsernamePasswordToken(name, pwd,rememberMe);
        .	.	.
}

③ 验证rememberMe

○ 在MyController类中新增方法userRmLogin

@Controller
@RequestMapping("myController")
public class MyController {
	.	.	.
    //登录认证验证rememberMe
    @GetMapping("/userLoginRm")
    public String userRmLogin(HttpSession session){
        session.setAttribute("user","rememberMe");
        return  "main";
    }
}

MyController完整代码如下：

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("/login")
    public String login(){
        return  "login";
    }

    @GetMapping("/userLogin")
    //@ResponseBody
    public String userLogin(String name, String pwd, HttpSession session, @RequestParam(defaultValue = "false")boolean rememberMe){
        System.out.println("userLogin被请求了！！！");
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd,rememberMe);
        try {
            //3.调用login方法进行登录认证
            subject.login(token);
            System.out.println("登录成功！！！");
            session.setAttribute("user",token.getPrincipal().toString());
            //return "登录成功";
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败！！！");
            return "登录失败！！！";
        }
    }

    //登录认证验证rememberMe
    @GetMapping("/userLoginRm")
    public String userRmLogin(HttpSession session){
        session.setAttribute("user","rememberMe");
        return  "main";
    }
}

○ 在ShiroConfig中添加存在用户的过滤器（rememberMe）

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    .	.	.

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
       	.	.	.
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return definition;
    }
}

完整代码如下：

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //6.返回
        return defaultWebSecurityManager;
    }


    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return definition;
    }
}

○ 修改登录页面src/main/resources/templates/login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro登录认证</h1>
    </br>
    <form action="/myController/userLogin">
        <div>用户名：<input type="text" name="name" value=""></div>
        <div>密码：<input type="password" name="pwd" value=""></div>
        <div><input type="submit" value="登录"></div>
        <div>记住用户：<input type="checkbox" name="rememberMe" value="true"></div>
    </form>
</body>
</html>

效果演示如下：
访问：http://localhost:8080/myController/userLoginRm

使用rememberMe后，浏览器关闭再次请求http://localhost:8080/myController/userLoginRm会免登录

3. 用户登录认证后登出

用户登录后，配套的有登出操作。直接通过Shiro过滤器即可实现登出

⑴ 代码实现

1）修改登录后的main.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    .	.	.
    <a href="/logout">登出</a>
</body>
</html>

完整代码如下：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证后主页面</h1>
    </br>
    登录用户为：<span th:text="${session.user}"></span>
    </br>
    <a href="/logout">登出</a>
</body>
</html>

2）ShiroConfig中添加登出过滤器

@Configuration
public class ShiroConfig {
   	.	.	.
    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
       	.	.	.
        //设置登出过滤器
        definition.addPathDefinition("/logout","logout");
        .	.	.
        return definition;
    }
}

完整代码如下：

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //6.返回
        return defaultWebSecurityManager;
    }


    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置登出过滤器
        definition.addPathDefinition("/logout","logout");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return definition;
    }
}

测试效果如下：

4. 授权、角色认证

⑴ 授权

用户登录后，需要验证是否具有指定角色指定权限。Shiro也提供了方便的工具进行判断。
这个工具就是Realm的doGetAuthorizationInfo方法进行判断。触发权限判断的有两种方式e

• (1)在页面中通过shiro:****属性判断
• (2)在接口服务中通过注解@Requires****进行判断

⑵ 后端接口服务注解

通过给接口服务方法添加注解可以实现权限校验，可以加在控制器方法上，也可以加在业务方法上，一般加在控制器方法上。常用注解如下:

• (1) @RequiresAuthentication
  验证用户是否登录，等同于方法subject.isAuthenticated()

• (2) @RequiresUser
  验证用户是否被记忆:
  登录认证成功subject.isAuthenticated()为true
  登录后被记忆subject.isRemembered()为true

• (3) @RequiresGuest
  验证是否是一个guest的请求，是否是游客的请求
  此时subject.getPrincipal()为null

• (4) @RequiresRoles
  验证subject是否有相应角色，有角色访问方法，没有则会抛出异常AuthorizationException。
  例如:

  @RequiresRoles("aRoleName")
  void someMethod();
  //只有subject有aRoleName角色才能访问方法someMethod()
  

• (5) @RequiresPermissionse
  验证subject是否有相应权限，有权限访问方法，没有则会抛出异常AuthorizationException。
  例如:

  @RequiresPermissions("file:read","wite:aFile.txt")
  void someMethod();
  //subject必须同时含有file:read和wite:aFile.txt权限才能访问方法someMethod()
  

⑶ 授权验证——没有角色无法访问

1) MyController中添加userLoginRoles方法

@Controller
@RequestMapping("myController")
public class MyController {
	.	.	.
    //登录认证验证角色
    @RequiresRoles("admin")
    @GetMapping("userLoginRoles")
    @ResponseBody
    public String userLoginRoles(){
        System.out.println("登录认证验证角色");
        return "验证角色成功";
    }
}

完整代码如下：

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("/login")
    public String login(){
        return  "login";
    }

    @GetMapping("/userLogin")
    //@ResponseBody
    public String userLogin(String name, String pwd, HttpSession session, @RequestParam(defaultValue = "false")boolean rememberMe){
        System.out.println("userLogin被请求了！！！");
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd,rememberMe);
        try {
            //3.调用login方法进行登录认证
            subject.login(token);
            System.out.println("登录成功！！！");
            session.setAttribute("user",token.getPrincipal().toString());
            //return "登录成功";
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败！！！");
            return "登录失败！！！";
        }
    }

    //登录认证验证rememberMe
    @GetMapping("/userLoginRm")
    public String userRmLogin(HttpSession session){
        session.setAttribute("user","rememberMe");
        return  "main";
    }

    //登录认证验证角色
    @RequiresRoles("admin")
    @GetMapping("userLoginRoles")
    @ResponseBody
    public String userLoginRoles(){
        System.out.println("登录认证验证角色");
        return "验证角色成功";
    }
}

2) 修改main.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证后主页面</h1>
    </br>
    登录用户为：<span th:text="${session.user}"></span>
    </br>
    <a href="/logout">登出</a>
    <a href="/myController/userLoginRoles">测试授权</a>
</body>
</html>

3) 修改MyRealm方法

//自定义授权方法
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("进入自定义授权方法");
    return null;
}

完整代码如下：

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        return null;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用业务层获取用户信息（数据库）
        User user = userService.getUserInfoByName(name);
        //3.非空判断，将数据封装返回
        if(user != null){
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

测试效果如下：

测试结果为该用户没有admin角色

⑷ 授权验证——获取角色进行验证

1）修改MyRealm方法：通过后端写死的方式给用户添加admin角色

//自定义授权方法
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("进入自定义授权方法");
    //1.创建对象，封装当前登录用户的角色、权限信息
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //2.存储角色
    info.addRole("admin");
    //3.返回信息
    return info;
}

测试效果如下:

2) 创建角色表

CREATE TABLE `role`(
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` VARCHAR(30) DEFAULT NULL COMMENT '角色名',
  `desc` VARCHAR(50) DEFAULT NULL COMMENT '描述',
  `realname` VARCHAR(20) DEFAULT NULL COMMENT '角色显示名称',
   PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=2  DEFAULT CHARSET=utf8 COMMENT="角色表";
INSERT INTO `role` (`id`, `name`, `desc`, `realname`) VALUES('1','admin','所有权限','管理员');
INSERT INTO `role` (`id`, `name`, `desc`, `realname`) VALUES('2','userMag','用户管理权限','用户管理');

3) 创建角色用户映射表

CREATE TABLE `role_user`(
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `uid` BIGINT(20) DEFAULT NULL COMMENT '用户id',
  `rid` BIGINT(20) DEFAULT NULL COMMENT '角色id',
   PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=2  DEFAULT CHARSET=utf8 COMMENT="角色用户映射表";
INSERT INTO `role_user` (`id`, `uid`, `rid`) VALUES('1','1','1');
INSERT INTO `role_user` (`id`, `uid`, `rid`) VALUES('2','1','2');
INSERT INTO `role_user` (`id`, `uid`, `rid`) VALUES('3','2','2');

4) 编写mapper接口

@Repository
public interface UserMapper extends BaseMapper<User> {
	//根据用户查询角色信息
    @Select("SELECT NAME FROM ROLE WHERE id IN (SELECT rid FROM role_user WHERE uid =(SELECT id FROM user WHERE NAME = #{pricipal}))")
    List<String> getUserRoleInfoMapper(@Param("principal") String principal);
}

5) Service层编辑

UserService.class

public interface UserService extends IService<User> {
    User getUserInfoByName(String name);

    //根据用户查询角色信息
    List<String> getUserRoleInfoMapper(String principal);
}

Service实现类UserServiceImp

@Service
public class UserServiceImp extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public User getUserInfoByName(String name) {
        QueryWrapper<User> userWrapper = new QueryWrapper<>();
        userWrapper.eq("name",name);
        User user = userMapper.selectOne(userWrapper);
        return user;
    }

    //根据用户查询角色信息
    @Override
    public List<String> getUserRoleInfoMapper(String principal) {
        List<String> userRoleInfos = userMapper.getUserRoleInfoMapper(principal);
        return userRoleInfos;
    }
}

6) 修改MyRealm方法：从数据库获取用户角色信息

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取用户身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roleInfos = userService.getUserRoleInfoMapper(principal);
        System.out.println("当前用户的角色信息为："+roleInfos);
        //3.创建对象，封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //4.存储角色
        info.addRoles(roleInfos);
        //5.返回信息
        return info;
    }
   .	.	.
}

完整代码如下：

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取用户身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roleInfos = userService.getUserRoleInfoMapper(principal);
        System.out.println("当前用户的角色信息为："+roleInfos);
        //3.创建对象，封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //4.存储角色
        info.addRoles(roleInfos);
        //5.返回信息
        return info;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用业务层获取用户信息（数据库）
        User user = userService.getUserInfoByName(name);
        //3.非空判断，将数据封装返回
        if(user != null){
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

测试效果如下：

⑸ 授权验证——获取权限进行验证

获取权限验证和获取角色相类似

1）创建权限表

CREATE TABLE `permissions`(
   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` VARCHAR(30) DEFAULT NULL COMMENT '权限名',
  `info` VARCHAR(30) DEFAULT NULL COMMENT '权限信息',
  `desc` VARCHAR(50) DEFAULT NULL COMMENT '描述',
   PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=2  DEFAULT CHARSET=utf8 COMMENT="权限表";
INSERT INTO `permissions` (`id`, `name`, `info`, `desc`) VALUES('1','删除用户','user:delete','删除用户');
INSERT INTO `permissions` (`id`, `name`, `info`, `desc`) VALUES('2','新增用户','user:add','新增用户');
INSERT INTO `permissions` (`id`, `name`, `info`, `desc`) VALUES('3','修改用户','user:edit','修改用户');

2）创建角色和权限映射表

CREATE TABLE `role_ps`(
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `rid` BIGINT(20) DEFAULT NULL COMMENT '角色id',
  `pid` BIGINT(20) DEFAULT NULL COMMENT '权限id',
   PRIMARY KEY(`id`)
)ENGINE=INNODB AUTO_INCREMENT=2  DEFAULT CHARSET=utf8 COMMENT="角色权限映射表";
INSERT INTO `role_ps` (`id`, `rid`, `pid`) VALUES('1','1','1');
INSERT INTO `role_ps` (`id`, `rid`, `pid`) VALUES('2','1','2');
INSERT INTO `role_ps` (`id`, `rid`, `pid`) VALUES('3','1','3');

3）编写mapper接口

① mapper接口

@Repository
public interface UserMapper extends BaseMapper<User> {
	.	.	.
    List<String> getUserPermissionInfoMapper(@Param("roles") List<String> roles);
}

完整代码如下：

@Repository
public interface UserMapper extends BaseMapper<User> {
    @Select("SELECT NAME FROM ROLE WHERE id IN (SELECT rid FROM role_user WHERE uid =(SELECT id FROM user WHERE NAME = #{principal}))")
    List<String> getUserRoleInfoMapper(@Param("principal") String principal);
    
    List<String> getUserPermissionInfoMapper(@Param("roles") List<String> roles);
}

② src/main/resources/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">
<mapper namespace="com.kejizhentan.shiro.mapper.UserMapper">

    <select id="getUserPermissionInfoMapper" resultType="java.lang.String">
        SELECT info FROM permissions WHERE id IN (
            SELECT pid FROM role_ps WHERE rid IN (
                SELECT id FROM role WHERE
                <if test="roles != null and roles.size() >0">
                    name IN
                    <foreach collection="roles" item="name" separator="," open="(" close=")">
                        #{name}
                    </foreach>
                </if>
            )
        )
    </select>
</mapper>

4) Service层编辑

UserService.class

public interface UserService extends IService<User> {
    .	.	.
    //根据角色获取用户的权限信息
    List<String> getUserPermissionInfoMapper(List<String> roles);
}

完整代码如下：

public interface UserService extends IService<User> {
    User getUserInfoByName(String name);

    //根据用户查询角色信息
    List<String> getUserRoleInfoMapper(String principal);

    //根据角色获取用户的权限信息
    List<String> getUserPermissionInfoMapper(List<String> roles);
}

Service实现类UserServiceImp

@Service
public class UserServiceImp extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
	.	.	.
    //根据角色获取用户的权限信息
    @Override
    public List<String> getUserPermissionInfoMapper(List<String> roles) {
        return userMapper.getUserPermissionInfoMapper(roles);
    }
}

完整代码如下：

@Service
public class UserServiceImp extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public User getUserInfoByName(String name) {
        QueryWrapper<User> userWrapper = new QueryWrapper<>();
        userWrapper.eq("name",name);
        User user = userMapper.selectOne(userWrapper);
        return user;
    }

    //根据用户查询角色信息
    @Override
    public List<String> getUserRoleInfoMapper(String principal) {
        List<String> userRoleInfos = userMapper.getUserRoleInfoMapper(principal);
        return userRoleInfos;
    }

    //根据角色获取用户的权限信息
    @Override
    public List<String> getUserPermissionInfoMapper(List<String> roles) {
        return userMapper.getUserPermissionInfoMapper(roles);
    }
}

5) 修改MyRealm方法：从数据库获取用户的权限信息

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取用户身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roleInfos = userService.getUserRoleInfoMapper(principal);
        System.out.println("当前用户的角色信息为："+roleInfos);
        //3.调用业务层通过角色信息获取用户的权限信息(数据库)
        List<String> permissionInfos = userService.getUserPermissionInfoMapper(roleInfos);
        System.out.println("当前用户的权限信息为："+permissionInfos);
        //4.创建对象，封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //5.存储角色
        info.addRoles(roleInfos);
        //6.存储权限
        info.addStringPermissions(permissionInfos);
        //7.返回信息
        return info;
    }
    .	.	.
}

完整代码如下：

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;


    //自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("进入自定义授权方法");
        //1.获取用户身份信息
        String principal = principalCollection.getPrimaryPrincipal().toString();
        //2.调用业务层获取用户的角色信息(数据库)
        List<String> roleInfos = userService.getUserRoleInfoMapper(principal);
        System.out.println("当前用户的角色信息为："+roleInfos);
        //3.调用业务层通过角色信息获取用户的权限信息(数据库)
        List<String> permissionInfos = userService.getUserPermissionInfoMapper(roleInfos);
        System.out.println("当前用户的权限信息为："+permissionInfos);
        //4.创建对象，封装当前登录用户的角色、权限信息
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //5.存储角色
        info.addRoles(roleInfos);
        //6.存储权限
        info.addStringPermissions(permissionInfos);
        //7.返回信息
        return info;
    }

    //自定义登录认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户身份信息
        String name = authenticationToken.getPrincipal().toString();
        //2.调用业务层获取用户信息（数据库）
        User user = userService.getUserInfoByName(name);
        //3.非空判断，将数据封装返回
        if(user != null){
            AuthenticationInfo info = new SimpleAuthenticationInfo(
                    authenticationToken.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    authenticationToken.getPrincipal().toString()
            );
            return info;
        }
        return null;
    }
}

6) MyController中添加userLoginPermissions方法

@Controller
@RequestMapping("myController")
public class MyController {
	.	.	.
    //登录认证验证权限
    @RequiresPermissions("user:delete")
    @GetMapping("/userLoginPermissions")
    @ResponseBody
    public String userLoginPermissions(){
        System.out.println("登录认证验证权限");
        return "验证权限成功";
    }
}

完整代码如下：

@Controller
@RequestMapping("myController")
public class MyController {

    //跳转登录页面
    @GetMapping("/login")
    public String login(){
        return  "login";
    }

    @GetMapping("/userLogin")
    //@ResponseBody
    public String userLogin(String name, String pwd, HttpSession session, @RequestParam(defaultValue = "false")boolean rememberMe){
        System.out.println("userLogin被请求了！！！");
        //1.获取subject对象
        Subject subject = SecurityUtils.getSubject();
        //2.封装请求数据到token
        AuthenticationToken token = new UsernamePasswordToken(name, pwd,rememberMe);
        try {
            //3.调用login方法进行登录认证
            subject.login(token);
            System.out.println("登录成功！！！");
            session.setAttribute("user",token.getPrincipal().toString());
            //return "登录成功";
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败！！！");
            return "登录失败！！！";
        }
    }

    //登录认证验证rememberMe
    @GetMapping("/userLoginRm")
    public String userRmLogin(HttpSession session){
        session.setAttribute("user","rememberMe");
        return  "main";
    }

    //登录认证验证角色
    @RequiresRoles("admin")
    @GetMapping("/userLoginRoles")
    @ResponseBody
    public String userLoginRoles(){
        System.out.println("登录认证验证角色");
        return "验证角色成功";
    }

    //登录认证验证权限
    @RequiresPermissions("user:delete")
    @GetMapping("/userLoginPermissions")
    @ResponseBody
    public String userLoginPermissions(){
        System.out.println("登录认证验证权限");
        return "验证权限成功";
    }
}

7）修改登录后的main.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证后主页面</h1>
    </br>
    登录用户为：<span th:text="${session.user}"></span>
    </br>
    <a href="/logout">登出</a>
    </br>
    <a href="/myController/userLoginRoles">测试授权-验证角色</a>
    </br>
    <a href="/myController/userLoginPermissions">测试授权-验证权限</a>
</body>
</html>

测试效果如下：

⑹ 授权验证——异常处理

1）创建认证异常处理类，使用@ControllerAdvice 加@ExceptionHandler 实现特殊异处理

@ControllerAdvice
public class PermissionsException {
    @ResponseBody
    @ExceptionHandler(UnauthenticatedException.class)
    public String unauthenticatedException(Exception ex){
        return "无权限";
    }

    @ResponseBody
    @ExceptionHandler(AuthorizationException.class)
    public String authorizationException(Exception ex){
        return "权限认证失败";
    }
}

2）使用李四用户登录测试

因为李四不具有admin角色和user:delete权限，所以验证角色和权限都失败，抛异常被异常处理类捕获

⑺ 前端页面授权验证

1）添加依赖

<!--配置Thymeleaf与shiro的整合依赖-->
<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>

2）配置类添加新配置

用于解析 thymeleaf 中的 shiro:相关属性

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

完整代码如下：

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //6.返回
        return defaultWebSecurityManager;
    }


    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置登出过滤器
        definition.addPathDefinition("/logout","logout");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return definition;
    }

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

3）Thymeleaf中常用的shiro：属性

① guest标签

用户没有身份验证时显示相应信息，即游客访问信息

<shiro:guest>
</shiro:guest>

② user标签

用户已经身份验证/记住我登录后显示相应的信息。

<shiro:user>
</shiro:user>

③ authenticated 标签

用户已经身份验证通过，即 Subiect.login 登录成功，不是记住我登录的。

<shiro:authenticated>
</shiro:authenticated>

④ notAuthenticated标签

用户已经身份验证通过，即没有调用 Subiect.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 >

⑧ hasAnyRoles 标签

如果当前 Subject 有任意一个角色(或的关系)将显示 body 体内容。

<shiro:hasAnyRoles  name="admin,user">
</shiro:hasAnyRoles>

⑨ lacksRole标签

如果当前 Subject 没有角色将显示 body 体内容。

<shiro:lacksRole  name="abc">
</shiro:lacksRole>

⑩ hasPermission 标签

如果当前Subject 有权限将显示 body 体内容

<shiro:hasPermission   name="user:create">
</shiro:hasPermission>

4）使用shiro：属性改造main.html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证后主页面</h1>
    </br>
    登录用户为：<span th:text="${session.user}"></span>
    </br>
    <a href="/logout">登出</a>
    </br>
    <a shiro:hasRole="admin" href="/myController/userLoginRoles">测试授权-验证角色</a>
    </br>
    <a shiro:hasPermission="user:delete" href="/myController/userLoginPermissions">测试授权-验证权限</a>
</body>
</html

测试效果如下：

5. 实现缓存

⑴ 缓存工具EhCache

EhCache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。可以和大部分Java项目无缝整合，例如: Hibernate中的缓存就是基于EhCache实现的。
EhCache支持内存和磁盘存储，默认存储在内存中，如内存不够时把缓存数据同步到磁盘中。EhCache支持基于Filter的Cache实现，也支持Gzip压缩算法。
EhCache直接在JVM虚拟机中缓存，速度快，效率高;
EhCache缺点是缓存共享麻烦，集群分布式应用使用不方便

⑵ shiro整合EhCache

Shiro官方提供了shiro-ehcache，实现了整合EhCache作为Shiro的缓存工具。可以缓存认证执行的Realm方法，减少对数据库的访问，提高认证效率

1）添加依赖

<!--shiro整合EhCache-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

2）src/main/resources下创建ehcache/ehcache-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="ehcache" updateCheck="false">

    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir"/>
    <!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="1000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="false">
    </defaultCache>

    <!-- 登录记录缓存 锁定10分钟 -->
    <cache name="loginRecordCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

</ehcache>

3）在config.ShiroConfig.java中配置缓存管理器

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
       	.	.	.
        //6.设置缓存管理器
        defaultWebSecurityManager.setCacheManager(getEncacheManager());
        //7.返回
        return defaultWebSecurityManager;
    }

    //缓存管理器
    @Bean
    public EhCacheManager getEncacheManager(){
        EhCacheManager ehCacheManager = new EhCacheManager();
        InputStream is = null;
        try {
            is = ResourceUtils.getInputStreamForPath("classpath:ehcache/ehcache-shiro.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        net.sf.ehcache.CacheManager cacheManager = new net.sf.ehcache.CacheManager(is);
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

    .	.	.
}

完整代码如下

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        //1.创建defaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //2.创建加密对象设置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        //2.1采用md5加密
        matcher.setHashAlgorithmName("md5");
        //2.2迭代加密次数
        matcher.setHashIterations(3);
        //3.将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
        //4.将myRealm存储到defaultWebSecurityManager
        defaultWebSecurityManager.setRealm(myRealm);
        //5.设置rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());

        //6.设置缓存管理器
        defaultWebSecurityManager.setCacheManager(getEncacheManager());
        //6.返回
        return defaultWebSecurityManager;
    }

    //缓存管理器
    @Bean
    public EhCacheManager getEncacheManager(){
        EhCacheManager ehCacheManager = new EhCacheManager();
        InputStream is = null;
        try {
            is = ResourceUtils.getInputStreamForPath("classpath:ehcache/ehcache-shiro.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        net.sf.ehcache.CacheManager cacheManager = new net.sf.ehcache.CacheManager(is);
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

    //cookie属性设置
    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        //设置跨域
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30*24*60*60);
        return cookie;
    }

    //创建Shiro的cookie管理对象
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置shiro内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition definition = new DefaultShiroFilterChainDefinition();
        //设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin","anon");
        definition.addPathDefinition("/login","anon");
        //设置登出过滤器
        definition.addPathDefinition("/logout","logout");
        //设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**","authc");
        //添加存在用户的过滤器（rememberMe）
        definition.addPathDefinition("/**","user");
        return definition;
    }

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

测试结果如下：

6. 会话管理

会话管理器，负责创建和管理用户的会话(Session)生命周期，它能够在任何环境中在本地管理用户会话，即使没有Web/Servlet/EJB容器，也一样可以保存会话。默认情况下，Shiro会检测当前环境中现有的会话机制(比如Servlet容器)进行适配，如果没有(比如独立应用程序或者非Web环境)，它将会使用内置的企业会话管理器来提供相应的会话管理服务，其中还涉及一个名为SessionDA0的对象。SessionDA0负责Session的持久化操作(CRUD)，允许Session数据写入到后端持久化数据库。

⑴ 会话管理实现

SessionManager由SecurityManager管理。Shiro提供了三种实现

• DefaultSessionManager: 用于JavaSE环境e
• ServletContainerSessionManager: 用于web环境，直接使用Servlet容器的会话
• DefaultWebSessionManager:用于web环境，自己维护会话(不使用Servlet容器的会话管理)

⑵ 获得session方式

1) 实现

Session  session = SecurityUitils.getSubject().getSession();
session.setAttribute（"key","value"）

2)说明

Controller中的request，在shiro过滤器中的doFilerInternal方法，被包装成ShiroHttpServletReques。
SecurityManager和SessionManager 会话管理器决定 session 来源于ServletRequest还是由 Shiro管理的会话。
无论是通过 request.getSession 或subject.getSession 获取到 session，操作`session，两者都是等价的。

完整代码如下：https://kejizhentan.lanzoue.com/it4Gv0jh0aqd