Shiro认证授权-超详细，看这篇就够了

Shiro 简介

一、Shiro简介

Shiro是apache旗下的一个开源安全框架，它可以帮助我们完成身份认证，授权、加密、会话管理等功能。它有如下特点：

• 易于理解的API
• 简单的身份认证，支持多种数据源
• 简单的授权和鉴权
• 简单的加密API
• 支持缓存，以提升应用程序的性能
• 内置会话管理，适用于Web以及非Web的环境
• 不跟任何的框架或者容器捆绑，可以独立运行

（一）认证

认证即系统判断用户的身份是否合法，合法可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录、二维码登录、手机短信登录、脸部识别认证、指纹认证等方式。

认证是为了保护系统的隐私数据与资源，用户的身份合法才能访问该系统的资源。

（二）授权

授权即认证通过后，根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有权限则拒绝访问。 比如在一些视频网站中，普通用户登录后只有观看免费视频的权限，而VIP用户登录后，网站会给该用户提供观看VIP视频的权限。

认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐私数据进行划分，控制不同的用户能够访问不同的资源。

举个例子：认证是公司大门识别你作为员工能进入公司，而授权则是由于你作为公司会计可以进入财务室，查看账目，处理财务数据。

二、Shiro核心功能

• Authentication：身份认证/登录。
• Authorization：权限验证，即判断用户是否能在系统中做某件事情。
• Session Management：会话管理，用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中，会话可以是JavaSE环境的，也可以是Web环境的。
• Cryptography：加密，保护数据的安全性。即密码加密存储到数据库，而不是明文存储。
• Web Support：Web 支持，可以非常容易的集成到Web环境。
• Caching：缓存。在用户登录后，用户信息、拥有的权限不必每次去查，这样可以提高效率。
• Concurrency：Shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去。
• Testing：提供测试支持。
• Run As：允许一个用户假装为另一个用户的身份进行访问。
• Remember Me：记住我，即一次登录后，下次再来就不用登录了。

Shiro入门

一、SpringBoot整合Shiro项目搭建

1. 准备名为myshiro的mysql数据库

2. 创建SpringBoot项目，加入相关依赖

   <dependencies>
   <!-- SpringMVC -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <!-- Thymeleaf -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-thymeleaf</artifactId>
     </dependency>
     <!-- Mysql驱动 -->
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <scope>runtime</scope>
     </dependency>
     <!-- MyBatisPlus -->
     <dependency>
       <groupId>com.baomidou</groupId>
       <artifactId>mybatis-plus-boot-starter</artifactId>
       <version>3.5.0</version>
     </dependency>
     <!-- shiro和spring整合包 -->
     <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-spring</artifactId>
       <version>1.9.0</version>
     </dependency>
     <!-- lombok -->
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <optional>true</optional>
     </dependency>
     <!-- Junit -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
     <!-- Spring-jdbc -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-jdbc</artifactId>
     </dependency>
   </dependencies>
   

3. 编写配置文件application.yml

   server:
     port: 80
   
   
   #日志格式
   logging:
     pattern:
      console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'
   
   
   # 数据源
   spring:
     datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://{ip}:{port}/myshiro?serverTimezone=UTC
      username: root
      password: root
   
   

4. 将前端资源复制到项目中

5. 编写页面跳转控制器

   @Controller
   public class PageController {
     @RequestMapping("/{page}")
     public String showPage(@PathVariable String page) {
       return page;
      }
   
   
     // 忽略favicon.ico的获取
     @GetMapping("favicon.ico")
     @ResponseBody
     public void noFavicon() {}
   }
   
   

6. 启动项目，访问登录页http://localhost/login

二、配置文件认证

Shrio支持多种数据源，我们首先将用户名密码写入配置文件，让Shiro读取配置文件进行认证。

1. 在resources目录下编写配置文件shiro.ini

   #声明用户账号
   [users]
   username=123
   

2. 编写登录控制器方法

   @Controller
   public class LoginController {
     @RequestMapping("/user/login")
     public String login(String username,String password){
       // 1.获取SecurityManager工厂，读取配置文件
       IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
       // 2.获取SecurityManager对象
       SecurityManager securityManager = factory.getInstance();
       // 3.将SecurityManager对象设置到运行环境中
       SecurityUtils.setSecurityManager(securityManager);
       // 4.获取Subject对象
       Subject subject = SecurityUtils.getSubject();
       // 5.将前端传来的用户名密码封装为Shiro提供的身份对象
       UsernamePasswordToken token = new UsernamePasswordToken(username, password);
       try {
         // 6.shiro认证
         subject.login(token);
         // 7.认证通过跳转到主页面
         return "main";
        }catch (AuthenticationException e){
         // 8.认证不通过跳转到失败页面
         return "fail";
        }
      }
   }
   
   

3. 启动项目，访问登录页http://localhost/login，测试登录功能。

三、数据库认证

在真实开发中，我们往往会使用数据库作为数据源进行认证操作。Realm负责连接数据源并进行具体认证，它有一个子类JdbcRealm，该类可以自动连接数据库认证。

创建数据表

CREATE TABLE `users` (
 `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `users` VALUES ('baizhan', 'baizhan');

编写登录控制器方法

@RequestMapping("/user/login2")
public String login2(String username,String password){
  // 1.获取SecurityManager对象
  DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  // 2.为SecurityManager对象设置Realm
  JdbcRealm jdbcRealm = new JdbcRealm();
  jdbcRealm.setDataSource(dataSource);
  securityManager.setRealm(jdbcRealm);
  // 3.将SecurityManager对象设置到运行环境中
  SecurityUtils.setSecurityManager(securityManager);
  // 4.获取Subject对象
  Subject subject = SecurityUtils.getSubject();
  // 5.将前端传来的用户名密码封装为Shiro提供的身份对象
  UsernamePasswordToken token = new UsernamePasswordToken(username, password);
  try {
    // 6.shiro认证
    subject.login(token);
    // 7.认证通过跳转到主页面
    return "main";
   }catch (AuthenticationException e){
    // 8.认证不通过跳转到失败页面
    return "fail";
   }
}

启动项目，访问登录页http://localhost/login，测试登录功能。

Shiro认证

一、将Shiro交给容器管理

​ 关于Shiro的对象都是自己创建的。我们在SpringBoot中使用Shiro，就可以将Shiro的对象交给容器管理，简化业务代码。

创建shiro配制类：

@Configuration
public class ShiroConfig {
  // SecurityManager对象
  @Bean
  public DefaultWebSecurityManager getDefaultWebSecurityManager(JdbcRealm jdbcRealm){
    DefaultWebSecurityManager defaultSecurityManager=new DefaultWebSecurityManager();
    defaultSecurityManager.setRealm(jdbcRealm);
    return defaultSecurityManager;
   }

  // JdbcRealm
  @Bean
  public JdbcRealm getJdbcRealm(DataSource dataSource) {
    JdbcRealm jdbcRealm = new JdbcRealm();
    jdbcRealm.setDataSource(dataSource);
    return jdbcRealm;
   }
}

创建UserService.java

@Service
public class UsersService {
  @Autowired
  private DefaultWebSecurityManager securityManager;

  public void userLogin(String username, String password) throws AuthenticationException {
    // 1.将SecurityManager对象设置到运行环境中
    SecurityUtils.setSecurityManager(securityManager);
    // 2.获取Subject对象
    Subject subject = SecurityUtils.getSubject();
    // 3.将前端传来的用户名密码封装为Shiro提供的身份对象
    UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    // 4.Shiro认证
    subject.login(token);
   }
}

编写登录控制器方法

@RequestMapping("/user/login2")
public String login2(String username,String password){
  try {
    usersService.userLogin(username,password);
    return "main";
   }catch (AuthenticationException e){
    return "fail";
   }
}

二、自定义Realm

使用dbcRealm认证时，数据库表名、字段名、认证逻辑都不能改变，我们可以自定义 Realm进行更灵活的认证。

编写自定义Realm

public class MyRealm  extends AuthorizingRealm {


    @Autowired
    private UsersMapper usersMapper;

    //自定义认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken token1  = (UsernamePasswordToken) token;

        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("username",token1.getUsername());
        queryWrapper.eq("password",token1.getPassword());
        Users users = usersMapper.selectOne(queryWrapper);
        if (users == null){
            throw new UnknownAccountException("该用户不存在");
        }

        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(users,users.getPassword(),"myRealm");
        return info;
    }

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


}

将自定义Realm放入SecurityManager对象中

@Configuration
public class ShiroConfig {
  // 自定义Realm
  @Bean
  public MyRealm myRealm(){
    return new MyRealm();
   }
  
  // SecurityManager对象
  @Bean
  public DefaultWebSecurityManager getDefaultWebSecurityManager(MyRealm myRealm){
    DefaultWebSecurityManager defaultSecurityManager=new DefaultWebSecurityManager();
    // 自定义Realm放入SecurityManager中
    defaultSecurityManager.setRealm(myRealm);
    return defaultSecurityManager;
   }
}

三、多Realm认证

在实际开发中，我们的认证逻辑可能不止一种，例如：

• 系统支持用户名密码认证，也支持扫描二维码认证；
• 在系统中有管理员和普通用户两张表，管理员和普通用户的认证逻辑是不一样的；
• 用户数据量庞大，分别存在不同的数据库中，认证时需要连接多个数据源。

以上情况都需要配置多个Realm进行认证，我们以第二种情况举例，讲解Shiro中多Realm认证的写法：

在数据库创建admin表

CREATE TABLE `admin` (
 `id` int(11) NOT NULL,
 `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


INSERT INTO `admin` VALUES (1, 'admin', 'admin');
INSERT INTO `admin` VALUES (2, 'admin1', 'admin1');

创建Admin实体类和AdminMapper接口

@Data
public class Admin {
  private Integer id;
  private String name;
  private String password;
}


public interface AdminMapper extends BaseMapper<Admin> {
}

MyRealm认证User用户，MyRealm2认证Admin用户

public class MyRealm2 extends AuthorizingRealm {
  @Autowired
  private AdminMapper adminMapper;


  // 自定义认证方法
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    // 1.获取输入的管理员名
    UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    String username = token.getUsername();


    // 2.根据管理员名查询管理员
    QueryWrapper<Admin> wrapper = new QueryWrapper<Admin>().eq("name", username);
    Admin admin = adminMapper.selectOne(wrapper);


    // 3.将查询到的管理员封装为认证信息
    if (admin == null) {
      throw new UnknownAccountException("账户不存在");
     }


    /**
     * 参数1：管理员
     * 参数2：密码
     * 参数3：Realm名
     */
    return new SimpleAuthenticationInfo(admin,
        admin.getPassword(),
        "myRealm2");
   }


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

在SecurityManager中配置Realm

// Realm
@Bean
public MyRealm getMyRealm() {
  return new MyRealm();
}
@Bean
public MyRealm2 getMyRealm2() {
  return new MyRealm2();
}


// SecurityManager对象
@Bean
public DefaultWebSecurityManager getDefaultWebSecurityManager(MyRealm realm, MyRealm2 realm2){
  DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager();
  // Realm放入SecurityManager中
  List<Realm> realms = new ArrayList();
  realms.add(realm);
  realms.add(realm2);
  defaultSecurityManager.setRealms(realms);
  return defaultSecurityManager;
}

四、多Realm认证策略

如果有多个Realm，怎样才能认证成功，这就是认证策略。认证策略主要使用的是 AuthenticationStrategy接口，这个接口有三个实现类：

策略	意义
AtLeastOneSuccessfulStrategy（默认）	只要有一个Realm验证成功即可，返回所有成功的认证信息
FirstSuccessfulStrategy	只要有一个Realm验证成功即可**，**只返回第一个成功的认证信息，其他的忽略
AllSuccessfulStrategy	所有Realm验证成功才算成功，如果有一个失败则认证失败

// Realm管理者
@Bean
public ModularRealmAuthenticator modularRealmAuthenticator(){
  ModularRealmAuthenticator modularRealmAuthenticator = new ModularRealmAuthenticator();
  //设置认证策略
  modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
  return modularRealmAuthenticator;
}


// SecurityManager对象
@Bean
public DefaultWebSecurityManager getDefaultWebSecurityManager(MyRealm realm, MyRealm2 realm2){
  DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager();
  // 设置Realm管理者（需要在设置Realm之前）
  defaultSecurityManager.setAuthenticator(modularRealmAuthenticator());
  List<Realm> realms = new ArrayList();
  realms.add(realm);
  realms.add(realm2);
  defaultSecurityManager.setRealms(realms);
  return defaultSecurityManager;
}

在ModularRealmAuthenticator中的doMultiRealmAuthentication方法中添加断点可以查看认证通过信息

五、异常处理

当Shiro认证失败后，会抛出AuthorizationException异常。该异常的子类分别代表不同的认证失败原因，我们可以通过捕捉它们确定认证失败原因。

• DisabledAccountException：账户失效

• ConcurrentAccessException：竞争次数过多

• ExcessiveAttemptsException：尝试次数过多

• UnknownAccountException：用户名不正确

• IncorrectCredentialsException：凭证（密码）不正确

• ExpiredCredentialsException：凭证过期

  @RequestMapping("/user/login2")
  public String login(String username, String password) {
    try {
      usersService.userLogin(username, password);
      return "main";
     } catch (DisabledAccountException e) {
      System.out.println("账户失效");
      return "fail";
     } catch (ConcurrentAccessException e) {
      System.out.println("竞争次数过多");
      return "fail";
     } catch (ExcessiveAttemptsException e) {
      System.out.println("尝试次数过多");
      return "fail";
     } catch (UnknownAccountException e) {
      System.out.println("用户名不正确");
      return "fail";
     } catch (IncorrectCredentialsException e) {
      System.out.println("密码不正确");
      return "fail";
     } catch (ExpiredCredentialsException e) {
      System.out.println("凭证过期");
      return "fail";
     }
  }
  
  

六、散列算法

散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，适合于对密码进行加密。比如密码admin，产生的散列值是21232f297a57a5a743894a0e4a801fc3，但在md5解密网站很容易的通过散列值得到密码admin。所以在加密时我们可以加一些只有系统知道的干扰数据，这些干扰数据称之为“盐”，并且可以进行多次加密，这样生成的散列值相对来说更难破解。

Shiro支持的散列算法：

Md2Hash、Md5Hash、Sha1Hash、Sha256Hash、Sha384Hash、Sha512Hash

@SpringBootTest
public class Md5Test {
  @Test
  public void testMd5() {
    //使用MD5加密
    Md5Hash result1 = new Md5Hash("123");
    System.out.println("md5加密后的结果：" + result1);


    //加盐后加密,加密5次
    Md5Hash result2 = new Md5Hash("123","sxt",5);
    System.out.println("md5加盐加密后的结果：" + result2);
   }
}

修改数据库和实体类，添加盐字段，并修改数据库用户密码为加盐加密后的数据。

修改自定义Realm，添加盐：

@Component
public class MyRealm extends AuthorizingRealm {
  @Autowired
  private UserInfoMapper userInfoMapper;


  // 自定义认证方法
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    // 1.获取用户输入的用户名
    UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    String username = token.getUsername();


    // 2.根据用户名查询用户
    QueryWrapper<Users> wrapper = new QueryWrapper<Users>().eq("username", username);
    Users users = usersMapper.selectOne(wrapper);


    // 3.将查询到的用户封装为认证信息
    if (users == null) {
      throw new UnknownAccountException("账户不存在");
     }


    /**
     * 参数1：用户
     * 参数2：密码
     * 参数3：盐
     * 参数4：Realm名
     */
    return new SimpleAuthenticationInfo(users,
        users.getPassword(),
        ByteSource.Util.bytes(users.getSalt()),
        "myRealm");
   }


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

七、过滤器

在以上案例中，虽然有认证功能，但即使没有登录也可以访问系统资源。如果要配置认证后才能访问资源，就需要使用过滤器拦截请求。Shiro内置了很多过滤器：

过滤器	过滤器类	说明
anon	AnonymousFilter	配置不需要登录即可访问的资源
authc	FormAuthenticationFilter	配置登录认证后才可以访问的资源
user	UserFilter	配置登录认证或“记住我”认证后才可以访问的资源

// 配置过滤器
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
  // 1.创建过滤器工厂
  ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
  // 2.过滤器工厂设置SecurityManager
  filterFactory.setSecurityManager(securityManager);
  // 3.设置shiro的拦截规则
  Map<String,String> filterMap=new HashMap<>();
  // 不拦截的资源
  filterMap.put("/login.html","anon");
  filterMap.put("/fail.html","anon");
  filterMap.put("/user/login","anon");
  filterMap.put("/css/**","anon");
  // 其余资源都需要用户认证
  filterMap.put("/**","authc");
  // 4.将拦截规则设置给过滤器工厂
  filterFactory.setFilterChainDefinitionMap(filterMap);
  // 5.登录页面
  filterFactory.setLoginUrl("/login.html");
  return filterFactory;
}

实时效果反馈

1. 在Shiro中，anon过滤器表示

A 无需认证即可访问

B 需要登录认证才能访问

C 需要登录认证或记住我认证才能访问

D 需要特定权限才能访问

2. 在Shiro中，authc过滤器表示

A 无需认证即可访问

B 需要登录认证才能访问

C 需要登录认证或记住我认证才能访问

D 需要特定权限才能访问

答案

1=>A 2=>B

八、获取认证数据

用户认证通过后，有时我们需要获取用户信息，比如在网站顶部显示：欢迎您，XXX。获取用户信息的写法如下：

@RequestMapping("/user/getUsername")
@ResponseBody
public String getUsername(){
  Subject subject = SecurityUtils.getSubject();
  // 获取认证数据
  Users users = (Users)subject.getPrincipal();
  return users.getUsername();
}

实时效果反馈

1. 在Shiro中，方法可以获取认证数据

A subject.getUser()

B subject.getPrincipal()

C securityManager.getUser()

D securityManager.getPrincipal()

答案

1=>B

九、Shiro会话管理器

（一）会话功能

Shiro提供了完整的企业级会话管理功能，不依赖于Web容器，不管JavaSE还是JavaEE环境都可以使用。

// 使用Shiro提供的会话对象
@RequestMapping("/user/session")
@ResponseBody
public void session(){
  // 1.获取Subject
  Subject subject = SecurityUtils.getSubject();
  // 2.获取会话
  Session session = subject.getSession();

  // 会话id
  System.out.println("会话id:"+session.getId());
  // 会话的主机地址
  System.out.println("会话的主机地址:"+session.getHost());
  // 设置会话过期时间
  session.setTimeout(1000*10);
  // 获取会话过期时间
  System.out.println("会话过期时间:"+session.getTimeout());
  // 会话开始时间
  System.out.println("会话开始时间:"+session.getStartTimestamp());
  // 会话最后访问时间
  System.out.println("会话最后访问时间:"+session.getLastAccessTime());
  // 会话设置数据
  session.setAttribute("name","漫步阡陌");
}


@RequestMapping("/user/getSession")
@ResponseBody
public void getSession(){
  Subject subject = SecurityUtils.getSubject();
  Session session = subject.getSession();
  System.out.println(session.getAttribute("name"));
}

实时效果反馈

1. 在Shiro中，方法可以获取Shiro会话

A subject.getSession()

B subject.session()

C request.getSession()

D request.session()

答案

1=>A

（二）会话管理器

Shiro中提供了会话管理器，可以对会话对象进行配置和监听，用法如下：

@Component
public class MySessionListener implements SessionListener {
  //会话创建时触发
  @Override
  public void onStart(Session session) {
    System.out.println("会话创建：" + session.getId());
   }
  //会话过期时触发
  @Override
  public void onExpiration(Session session) {
    System.out.println("会话过期：" + session.getId());
   }
  //退出/会话过期时触发
  @Override
  public void onStop(Session session) {
    System.out.println("会话停止：" + session.getId());
   }
}

实时效果反馈

1. 在Shiro中，会话管理器对象为

A SessionManager

B SessionHandler

C SeManager

D SeHandler

2. 在Shiro中，会话监听器需要实现

A Listener

B SessionListener

C HttpSessionListener

D SessionFilter

答案

1=>A 2=>B

十、退出登录

在系统中一般都有退出登录的操作。退出登录后Shiro会销毁会话和认证数据。在Shrio中，退出登录的写法如下：

编写退出登录控制器

@RequestMapping("/user/logout")
public String logout(){
  Subject subject = SecurityUtils.getSubject();
  // 退出登录
  subject.logout();
  // 退出后跳转到登录页
  return "redirect:/login";
}

在主页面添加退出登录按钮

主页面

退出登录

十一、记住我

Remember Me为“记住我”功能，即登录成功后，下次访问系统时无需重新登录。当使用“记住我”功能登录后，Shiro会在浏览器Cookie中保存序列化后的认证数据。之后浏览器访问项目时会携带该Cookie数据，这样不登录也可以完成认证。

当然，为了安全起见，并不是所有资源都可以通过“记住我”访问。比如在电商系统中，查询商品等操作可以不登录，但是支付时往往需要重新登录，Shiro支持配置什么资源可以通过“记住我”访问。

实现“记住我”功能的写法如下：

序列化所有实体类

@Data
public class Users implements Serializable {
  private Integer uid;
  private String username;
  private String password;
  private String salt;
}

配置Cookie生成器和记住我管理器

// Cookie生成器
@Bean
public SimpleCookie simpleCookie() {
  SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
  // Cookie有效时间，单位：秒
  simpleCookie.setMaxAge(20);
  return simpleCookie;
}


// 记住我管理器
@Bean
public CookieRememberMeManager cookieRememberMeManager(SimpleCookie simpleCookie) {
  CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
  // Cookie生成器
  cookieRememberMeManager.setCookie(simpleCookie);
  // Cookie加密的密钥
  cookieRememberMeManager.setCipherKey(Base64.decode("6ZmI6I2j3Y+R1aSn5BOlAA=="));
  return cookieRememberMeManager;
}


@Bean
public DefaultWebSecurityManager securityManager(MyRealm myRealm,
                         MyRealm2 myRealm2,
                         SessionManager sessionManager,
                         CookieRememberMeManager rememberMeManager){
  DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  // 自定义Realm放入SecurityManager中
  //     securityManager.setRealm(myRealm);
  // 设置Realm管理者(需要设置在Realm之前)
  securityManager.setAuthenticator(modularRealmAuthenticator());
  List<Realm> realms = new ArrayList();
  realms.add(myRealm);
  //     realms.add(myRealm2);
  securityManager.setRealms(realms);
  securityManager.setSessionManager(sessionManager);
  securityManager.setRememberMeManager(rememberMeManager);
  return securityManager;
}

修改登录表单

<form class="form" action="/user/login" method="post">
  <input type="text" placeholder="用户名" name="username">
  <input type="password" placeholder="密码" name="password">
  <input type="checkbox" name="rememberMe" value="on">记住我<br>
  <button type="submit" id="login-button">登录</button>
</form>

修改登录控制器

@RequestMapping("/user/login")
public String login(String username, String password,String rememberMe) {
  try {
    usersService.userLogin(username, password,rememberMe);
    return "main";
   } catch (DisabledAccountException e) {
    System.out.println("账户失效");
    return "fail";
   } catch (ConcurrentAccessException e) {
    System.out.println("竞争次数过多");
    return "fail";
   } catch (ExcessiveAttemptsException e) {
    System.out.println("尝试次数过多");
    return "fail";
   } catch (UnknownAccountException e) {
    System.out.println("用户名不正确");
    return "fail";
   } catch (IncorrectCredentialsException e) {
    System.out.println("密码不正确");
    return "fail";
   } catch (ExpiredCredentialsException e) {
    System.out.println("凭证过期");
    return "fail";
   }
}

修改登录Service

@Service
public class UsersService {
  @Autowired
  private DefaultWebSecurityManager securityManager;


  public void userLogin(String username,String password,String rememberMe) throws AuthenticationException {
    SecurityUtils.setSecurityManager(securityManager);
    Subject subject = SecurityUtils.getSubject();
    UsernamePasswordToken token=new UsernamePasswordToken(username,password);
    if (rememberMe != null){
      // 如果用户选择记住我，则生成记住我Cookie
      token.setRememberMe(true);
     }
    subject.login(token);
   }
}

配置过滤器，配置可以通过“记住我”访问的资源。

@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
  // 1.创建过滤器工厂
  ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
  // 2.过滤器工厂设置SecurityManager
  filterFactory.setSecurityManager(securityManager);
  // 3.设置shiro的拦截规则
  Map<String,String> filterMap=new HashMap<>();
  // 不拦截的资源
  filterMap.put("/login.html","anon");
  filterMap.put("/fail.html","anon");
  filterMap.put("/user/login","anon");
  filterMap.put("/static/**","anon");
  // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; user过滤器表示配置记住我或认证都可以访问
  //     filterMap.put("/**","authc");
  filterMap.put("/user/pay","authc");
  filterMap.put("/**", "user");
  // 4.将拦截规则设置给过滤器工厂
  filterFactory.setFilterChainDefinitionMap(filterMap);
  // 5.登录页面
  filterFactory.setLoginUrl("/login.html");
  return filterFactory;
}

编写支付控制器

// 支付
@RequestMapping("/user/pay")
@ResponseBody
public String pay(){
  return "支付功能";
}

Shiro授权

一、RBAC权限表设计

授权即认证通过后，系统给用户赋予一定的权限，用户只能根据权限访问系统中的某些资源。所以在数据库中，用户需要和权限关联。除了用户表和权限表，还需要创建角色表，他们之间的关系如下：

用户角色，角色权限都是多对多关系，即一个用户拥有多个角色，一个角色拥有多个权限。如：张三拥有总经理和股东的角色，而总经理拥有查询工资、查询报表的权限；股东拥有查寻股权的权限，这样张三就拥有了查询工资、查询报表、查询股权的权限。

接下来我们创建除users外的其余表：

CREATE TABLE `role` (
 `rid` int(11) NOT NULL AUTO_INCREMENT,
 `roleName` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 `roleDesc` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 PRIMARY KEY (`rid`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `role` VALUES (1, '总经理', '管理整个公司');
INSERT INTO `role` VALUES (2, '股东', '参与公司决策');
INSERT INTO `role` VALUES (3, '财务', '管理公司资产');


CREATE TABLE `permission` (
 `pid` int(11) NOT NULL AUTO_INCREMENT,
 `permissionName` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 `url` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
 PRIMARY KEY (`pid`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `permission` VALUES (1, '查询报表', '/reportform/find');
INSERT INTO `permission` VALUES (2, '查询工资', '/salary/find');
INSERT INTO `permission` VALUES (3, '查询税务', '/tax/find');


CREATE TABLE `users_role` (
 `uid` int(255) NOT NULL,
 `rid` int(11) NOT NULL,
 PRIMARY KEY (`uid`, `rid`) USING BTREE,
 INDEX `rid`(`rid`) USING BTREE,
 CONSTRAINT `users_role_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`) ON DELETE RESTRICT ON UPDATE RESTRICT,
 CONSTRAINT `users_role_ibfk_2` FOREIGN KEY (`rid`) REFERENCES `role` (`rid`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `users_role` VALUES (1, 2);
INSERT INTO `users_role` VALUES (1, 3);


CREATE TABLE `role_permission` (
 `rid` int(11) NOT NULL,
 `pid` int(11) NOT NULL,
 PRIMARY KEY (`rid`, `pid`) USING BTREE,
 INDEX `pid`(`pid`) USING BTREE,
 CONSTRAINT `role_permission_ibfk_1` FOREIGN KEY (`rid`) REFERENCES `role` (`rid`) ON DELETE RESTRICT ON UPDATE RESTRICT,
 CONSTRAINT `role_permission_ibfk_2` FOREIGN KEY (`pid`) REFERENCES `permission` (`pid`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `role_permission` VALUES (1, 1);
INSERT INTO `role_permission` VALUES (2, 1);
INSERT INTO `role_permission` VALUES (1, 2);
INSERT INTO `role_permission` VALUES (3, 2);
INSERT INTO `role_permission` VALUES (1, 3);
INSERT INTO `role_permission` VALUES (2, 3);

二、数据库查询权限

在认证后进行授权需要根据用户id查询到用户的权限，写法如下：

编写用户、角色、权限实体类

@Data
public class Users implements Serializable {
  private Integer uid;
  private String username;
  private String password;
  private String salt;
}


// 角色
@Data
public class Role implements Serializable{
  private Integer rid;
  private String roleName;
  private String roleDesc;
}


// 权限
@Data
public class Permission implements Serializable{
  private Integer pid;
  private String permissionName;
  private String url;
}

修改UsersMapper接口

// 根据用户id查询权限
List<Permission> findPermissionById(Integer id);

在resources目录中编写UsersMapper的映射文件

<?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.itbaizhan.myshiro1.mapper.UsersMapper">
  <select id="findPermissionById" resultType="com.itbaizhan.myshiro1.domain.Permission">
     SELECT DISTINCT permission.pid,permission.permissionName,permission.url FROM
       users
         LEFT JOIN users_role on users.uid = users_role.uid
         LEFT JOIN role on users_role.rid = role.rid
         LEFT JOIN role_permission on role.rid = role_permission.rid
         LEFT JOIN permission on role_permission.pid = permission.pid
     where users.uid = #{uid}
  </select>
</mapper>

测试方法

@SpringBootTest
public class UserMapperTest {
  @Autowired
  private UsersMapper usersMapper;
  @Test
  public void testFindPermissionById(){
    List<Permission> permissions = usersMapper.findPermissionById(1);
    permissions.forEach(System.out::println);
   }
}

三、在Realm进行授权

在自定义Realm中可以自定义授权方法：

必须将用户的权限查询出来，在Realm中进行配置，每个用户的权限才能被Shiro进行管理

    // 自定义授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //1.拿到用户认证信息
        Users users = (Users) principalCollection.getPrimaryPrincipal();
        //2.从数据库中查询权限
        List<Permission> permissions = usersMapper.findPermissionById(users.getId());
        //3.遍历权限对象，将所有权限名交给Shiro管理
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        for (Permission permission : permissions) {
            authorizationInfo.addStringPermission(permission.getUrl());
        }
        return authorizationInfo;
    }

四、在过滤器配置鉴权

Shiro可以根据用户拥有的权限，控制具体资源的访问，这一过程称为鉴权。在Shiro中，可以通过过滤器进行鉴权配置：

过滤器	过滤器类	说明
roles	RolesAuthorizationFilter	角色授权过滤器，验证用户是否拥有某角色
perms	PermissionsAuthorizationFilter	权限授权过滤器，验证用户是否拥有某权限
port	PortFilter	端口过滤器，表示可以通过的端口，如果配置端口为80，而用户访问该页面是非80，自动将请求端口改为80并重定向到该80端口
rest	HttpMethodPermissionFilter	rest风格过滤器，自动根据请求方法构建权限字符串
ssl	SslFilter	SSL过滤器，只有请求协议是https才能通过，否则自动跳转会https端口（443）

配置过滤器

// 配置过滤器
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
  // 1.创建过滤器工厂
  ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
  // 2.过滤器工厂设置SecurityManager
  filterFactory.setSecurityManager(securityManager);
  // 3.设置shiro的拦截规则
  Map<String,String> filterMap=new HashMap<>();
  // 不拦截的资源
  filterMap.put("/login.html","anon");
  filterMap.put("/fail.html","anon");
  filterMap.put("/user/login","anon");
  filterMap.put("/css/**","anon");


  // 鉴权过滤器，要写在/**之前，否则认证都无法通过
  filterMap.put("/reportform/find", "perms[/reportform/find]");
  filterMap.put("/salary/find", "perms[/salary/find]");
  filterMap.put("/staff/find", "perms[/staff/find]");


  // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; user过滤器表示配置记住我或认证都可以访问
  //     filterMap.put("/**","authc");
  filterMap.put("/user/pay","authc");
  filterMap.put("/**", "user");
  
  // 4.将拦截规则设置给过滤器工厂
  filterFactory.setFilterChainDefinitionMap(filterMap);
  // 5.登录页面
  filterFactory.setLoginUrl("/login.html");
  return filterFactory;
}


// 编写测试控制器
@RestController
public class MyController {
  @GetMapping("/reportform/find")
  public String findReportform(){
    return "查询报表";
   }


  @GetMapping("/salary/find")
  public String findSalary(){
    return "查询工资";
   }


  @GetMapping("/staff/find")
  public String findStaff(){
    return "查询员工";
   }
}

此时如果权限不足会抛出401异常，我们可以自定义权限不足的跳转页面：

1. 编写权限不足页面

   您的权限不足，请联系管理员！

2. 配置权限不足的跳转页面

   // 配置过滤器
   @Bean
   public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
     // 1.创建过滤器工厂
     ShiroFilterFactoryBean filterFactory=new ShiroFilterFactoryBean();
     // 2.过滤器工厂设置SecurityManager
     filterFactory.setSecurityManager(securityManager);
     // 3.设置shiro的拦截规则
     Map<String,String> filterMap=new HashMap<>();
     // 不拦截的资源
     filterMap.put("/login.html","anon");
     filterMap.put("/fail.html","anon");
     filterMap.put("/noPermission.html","anon");
     filterMap.put("/user/login","anon");
     filterMap.put("/css/**","anon");
   
     // 鉴权过滤器
     filterMap.put("/reportform/find", "perms[/reportform/find]");
     filterMap.put("/salary/find", "perms[/salary/find]");
     filterMap.put("/staff/find", "perms[/staff/find]");
   
   
     // 其余资源都需要认证，authc过滤器表示需要认证才能进行访问; user过滤器表示配置记住我或认证都可以访问
     //     filterMap.put("/**","authc");
     filterMap.put("/user/pay","authc");
     filterMap.put("/**", "user");
     // 4.将拦截规则设置给过滤器工厂
     filterFactory.setFilterChainDefinitionMap(filterMap);
     // 5.登录页面
     filterFactory.setLoginUrl("/login.html");
     // 6.权限不足访问的页面
     filterFactory.setUnauthorizedUrl("/noPermission.html");
     return filterFactory;
   }
   
   

   1. 在Shiro中，perms过滤器表示

   A 无需认证即可访问

   B 需要登录认证才能访问

   C 需要登录认证或记住我认证才能访问

   D 需要特定权限才能访问

   答案

   1=>D

五、注解配置鉴权

除了过滤器，Shiro也提供了一些鉴权的注解。我们可以使用注解配置鉴权。

@RequiresGuest：不认证即可访问的资源。

@RequiresUser：通过登录方式或“记住我”方式认证后可以访问资源。

@RequiresAuthentication：通过登录方式认证后可以访问资源。

@RequiresRoles：认证用户拥有特定角色才能访问的资源

@RequiresPermissions：认证用户拥有特定权限才能访问的资源

在配置类开启Shiro注解

// 开启shiro注解的支持
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
  AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
  advisor.setSecurityManager(securityManager);
  return advisor;
}


// 开启aop注解支持
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
  DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
  defaultAAP.setProxyTargetClass(true);
  return defaultAAP;
}

在控制器方法上添加鉴权注解

@GetMapping("/test/index")
@RequiresGuest
public String testIndex() {
  return "访问首页";
}


@GetMapping("/test/user")
@RequiresUser
public String testUser() {
  return "用户中心";
}


@GetMapping("/test/pay")
@RequiresAuthentication
public String testPay() {
  return "支付中心";
}


@GetMapping("/tax/find")
@RequiresPermissions("/tax/find")
public String taxFind() {
  return "查询税务";
}


@GetMapping("/address/find")
@RequiresPermissions("/address/find")
public String addressFind() {
  return "查询地址";
}

注：如果这时候没有用户没有权限就会报500异常，不是原来的401异常不能自动跳转没有权限页面，你可以这样处理

   @Bean
    public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer() {
        return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
            @Override
            public void customize(ConfigurableWebServerFactory factory) {
                ErrorPage error500Page = new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/500");
                
                factory.addErrorPages(error500Page);
            }
        };
    }

//添加控制器

@RequestMapping("/500")
public String err() {
    return "noPermission";
}

常见的错误码：

CONTINUE(100, HttpStatus.Series.INFORMATIONAL, "Continue"),
SWITCHING_PROTOCOLS(101, HttpStatus.Series.INFORMATIONAL, "Switching Protocols"),
PROCESSING(102, HttpStatus.Series.INFORMATIONAL, "Processing"),
CHECKPOINT(103, HttpStatus.Series.INFORMATIONAL, "Checkpoint"),
OK(200, HttpStatus.Series.SUCCESSFUL, "OK"),
CREATED(201, HttpStatus.Series.SUCCESSFUL, "Created"),
ACCEPTED(202, HttpStatus.Series.SUCCESSFUL, "Accepted"),
NON_AUTHORITATIVE_INFORMATION(203, HttpStatus.Series.SUCCESSFUL, "Non-Authoritative Information"),
NO_CONTENT(204, HttpStatus.Series.SUCCESSFUL, "No Content"),
RESET_CONTENT(205, HttpStatus.Series.SUCCESSFUL, "Reset Content"),
PARTIAL_CONTENT(206, HttpStatus.Series.SUCCESSFUL, "Partial Content"),
MULTI_STATUS(207, HttpStatus.Series.SUCCESSFUL, "Multi-Status"),
ALREADY_REPORTED(208, HttpStatus.Series.SUCCESSFUL, "Already Reported"),
IM_USED(226, HttpStatus.Series.SUCCESSFUL, "IM Used"),
MULTIPLE_CHOICES(300, HttpStatus.Series.REDIRECTION, "Multiple Choices"),
MOVED_PERMANENTLY(301, HttpStatus.Series.REDIRECTION, "Moved Permanently"),
FOUND(302, HttpStatus.Series.REDIRECTION, "Found"),

注：测试@RequiresGuest时不要忘了删掉如下代码：

// 访问任何资源都需要认证
// filterMap.put("/**", "user");

实时效果反馈

1. 在Shiro中，@RequiresGuest表示

A 不认证即可访问的资源

B 通过登录方式或“记住我”方式认证后可以访问的资源。

C 通过登录方式认证后可以访问的资源。

D 认证用户拥有特定角色才能访问的资源。

2. 在Shiro中，@RequiresUser表示

A 无需认证即可访问

B 需要登录认证才能访问

C 需要登录认证或记住我认证才能访问

D 需要特定角色才能访问

答案

1=>A 2=>C

六、Thymeleaf中进行鉴权

Shrio可以在一些视图技术中进行控制显示效果。例如Thymeleaf中，只有认证用户拥有某些权限才会展示一些菜单。

在pom中引入Shiro和Thymeleaf的整合依赖

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

在配置文件中注册ShiroDialect

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

在Thymeleaf中使用Shiro标签，控制前端的显示内容

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
   xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
<head>
  <meta charset="UTF-8">
  <title>主页面</title>
</head>
<body>
<h1>主页面</h1>
<ul>
  <li shiro:hasPermission="/reportform/find"><a href="/reportform/find">查询报表</a></li>
  <li shiro:hasPermission="/salary/find"><a href="/salary/find">查询工资</a></li>
  <li shiro:hasPermission="/staff/find"><a href="/staff/find">查询员工</a></li>
</ul>
<h2><a href="/user/logout">退出登录</a></h2>
</body>
</html>

实时效果反馈

1. Shiro整合Thymeleaf，在网页标签中添加属性表示特定权限才能看到该内容

A th:hasPermission

B sec:hasPermission

C shiro:hasPermission

D shiro:hasRole

答案

1=>C

七、缓存

在Shiro中，每次拦截请求进行鉴权，都会去数据库查询该用户的权限信息。因为用户的权限信息在短时间内是不可变的，每次查询出来的数据其实都是重复数据，此时就会非常浪费资源。所以一般我们会将权限数据放在缓存中进行管理，这样我们就不用每次请求都查询数据库，提升了系统性能。

（一）为什么用缓存？

缓存即存在于内存中的一块数据。数据库的数据是存储在硬盘上的，而内存的读写效率要远远的高于数据库。但硬盘中保存的数据是持久化数据，断电后依然存在；而内存中保存的是临时数据，随时可能清空。所以我们为了提升系统性能，减少程序和数据库的交互，会将经常查询但不常改变的，改变后对结果影响不大的数据放入缓存中。

Shiro支持多种缓存产品，在课程中我们使用ehcache缓存用户的权限数据。

（二）Shiro整合ehcache

ehcache是用来管理缓存的一个工具，其缓存的数据可以放在内存中，也可以放在硬盘上。ehcache的核心是CacheManager，一切的ehcache的应用都是从CacheManager开始的。

1. 引入shiro和ehcache整合包

<!-- shiro和ehcache整合包 -->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.9.0</version>
</dependency>

2. 创建配置文件shiro-ehcache.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
        updateCheck="false">
     <diskStore path="java.io.tmpdir/Tmp_EhCache"/>
     <!--
       默认缓存设置
       maxElementsInMemory:缓存最大数目
       maxEntriesLocalHeap：指定允许在内存中存放元素的最大数量。
       timeToIdleSeconds：一个元素在不被请求的情况下允许在缓存中存活的最大时间。0表示永久有效。
       timeToLiveSeconds：无论一个元素闲置与否，其允许在Cache中存活的最大时间。0表示永久有效。
       diskExpiryThreadIntervalSeconds：检查元素是否过期的线程多久运行一次
      -->
     <defaultCache
         maxElementsInMemory="10000"
         timeToIdleSeconds="120"
         timeToLiveSeconds="120"
         diskExpiryThreadIntervalSeconds="120"/>
   
   
     <!-- 授权缓存设置 -->
     <cache name="authorizationCache"
         maxEntriesLocalHeap="2000"
         timeToIdleSeconds="0"
         timeToLiveSeconds="0">
     </cache>
   </ehcache>
   
   

3. 在配置文件创建CacheManager

// 创建CacheManager
@Bean
public EhCacheManager ehCacheManager() {
  EhCacheManager ehCacheManager = new EhCacheManager();
  ehCacheManager.setCacheManagerConfigFile("classpath:shiro-ehcache.xml");
  return ehCacheManager;
}

4. 在SecurityManager中配置CacheManager

   @Bean
   public DefaultWebSecurityManager securityManager(MyRealm myRealm,
                            MyRealm2 myRealm2,
                            SessionManager sessionManager,
                            CookieRememberMeManager rememberMeManager,
                            EhCacheManager ehCacheManager){
     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
     // 自定义Realm放入SecurityManager中
     //     securityManager.setRealm(myRealm);
     // 设置Realm管理者(需要设置在Realm之前)
     securityManager.setAuthenticator(modularRealmAuthenticator());
     List<Realm> realms = new ArrayList();
     realms.add(myRealm);
     //     realms.add(myRealm2);
     securityManager.setRealms(realms);
     securityManager.setSessionManager(sessionManager);
     securityManager.setRememberMeManager(rememberMeManager);
     securityManager.setCacheManager(ehCacheManager);
     return securityManager;
   }
   

   启动项目，测试权限缓存。你会发现，只有第一次查询数据库，第二次检权则没有对数据库进行查询

实时效果反馈

1. 缓存指

A 存在于处理器中的一块数据

B 存在于内存中的一块数据

C 存在于磁盘中的一块数据

D 存在于显卡中的一块数据

2. ehcache的核心是对象

A CacheHandler

B Cache

C CacheManager

D CacheManagement

答案

1=>B 2=>C

（三）Shiro整合redis

Shiro 、Redis简介

Shiro apache 出品的权限管理框架、Redis 基于内存的 NoSQL（非关系型数据库）非常适合作为 缓存使用

配置

目前已有Shiro 整合 Redis的项目 我们只需要 引入依赖，稍微配置一下即可使用

    <!-- shiro-redis -->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>2.4.2.1-RELEASE</version>
            <exclusions>
                <exclusion>
                    <artifactId>jedis</artifactId>
                    <groupId>redis.clients</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- redis 客户端 Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

整合Redis配置

    @Bean
    public RedisManager initRedisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setHost("127.0.0.1");
        redisManager.setPort(6379);
        return redisManager;
    }

    @Bean
    public RedisCacheManager initRedisCacheManager(RedisManager redisManager){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager);
        return redisCacheManager;
    }

    @Bean
    public DefaultSecurityManager securityManager(Realm realm,RedisCacheManager redisCacheManager) {
        DefaultSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        //添加缓存管理
        securityManager.setCacheManager(redisCacheManager);
        return securityManager;
    }