Shiro会话管理&&Ehcache缓存管理

目录

一、Shiro会话管理

        1.1 分析tomcat会话管理与Shiro会话管理的区别

        1.2 Shiro会话管理的使用

                1.2.1 实现SessionListener的监听器

                1.2.2 添加Spring-shiro的配置

                1.2.3 测试

二、Ehcache框架缓存管理

        2.1 关于缓存管理

        2.2 Ehcache缓存管理原理

        2.3 初始缓存

        2.4 Ehcache的使用

                2.4.1 导入pom依赖

                2.4.2 导入ehcache.xml文件

                2.4.3 导入EhcacheUtil类

                2.4.4 导入测试类进行测试

        2.5 授权使用缓存

                2.5.1 编写MyRealm的授权方法

                2.5.2 测试

---

一、Shiro会话管理

        1.1 分析tomcat会话管理与Shiro会话管理的区别

tomcat：用户第一次发送登录请求 ---> tomcat【将用户登录信息存入session】

               用户第二次发送功能请求 ---> 验证tomcat的session中是否存在用户的登录信息；

Shiro会话管理：用户第一次发送登录请求 ---> 对应多个tomcat

                           问题：会存在访问不到用户信息的tomcat的情况;

                           解决方法：【将用户登录信息存在tomcat的一个共有的位置ehcache中】

                           用户第二次发送功能请求 ---> 验证ehcache缓存中是否存在用户登录信息；

画图理解：

结论：

Shiro的会话管理具备tomcat的会话管理的一切功能，

同时相较于tomcat的session，Shiro提供了对于分布式session的管理；

以上就是我们为什么要学习Shiro会话管理的原因；

        1.2 Shiro会话管理的使用

                1.2.1 实现SessionListener的监听器

   MySessionListener

package com.leaf.ssm.shiro;

import org.apache.shiro.session.Session;
import org.apache.shiro.session.SessionListener;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-29 9:42
 */
public class MySessionListener implements SessionListener {

    @Override
    public void onStart(Session session) {
        //登录发请求时
        System.out.println("MySessionListener.onStart 执行..."+session.getId());
    }

    @Override
    public void onStop(Session session) {
        //退出时执行
        System.out.println("MySessionListener.onStop 执行..."+session.getId());
    }

    @Override
    public void onExpiration(Session session) {
        //session有效期到时
        System.out.println("MySessionListener.onExpiration 执行..."+session.getId());
    }
}

                1.2.2 添加Spring-shiro的配置

                        ① sessionManager

                        ② cookie模板

    applicationContext-shiro.xml

                1.2.3 测试

        我们登录以及退出查看依次打印的是哪些方法：

登录时：

退出时：

过期后：

访问方法：用户查询

结论：

当登录发送请求 会执行 监听器中的 onstart

当登出发送请求 会执行 监听器中的 onStop

当检查session过期时，会执行 监听器中的 onExpiration

过期时，需要身份验证才能访问的方法，就不会被允许访问；

---

二、Ehcache框架缓存管理

        2.1 关于缓存管理

例如Leaf的上篇文章写的那样的Shiro授权，它的性能是非常差的：

每一次访问新的功能或者单纯访问一个页面都会重新调用一次授权的方法，

也就是会走两次数据库，性能极大的不好；

而关于Ehcache的缓存管理就是用来解决这方面问题的！

        2.2 Ehcache缓存管理原理

所以我们Shiro在每次调用了用户角色权限方法后，

就把用户角色权限信息存到缓冲(内存)Ehcache中；

后面再需要访问是否拥有用户角色权限时就可以直接查询缓冲Ehcache，

如果缓冲中没有信息，才去查询数据库，并且把信息存储到Ehcache里；

这样就极大的提高了性能。

放上理解图： 

        2.3 初始缓存

    EhcacheDemo1

package com.leaf.ssm.shiro;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-29 11:23
 */
public class EhcacheDemo1 {

    static Map cache = new HashMap();
    //看做是查询数据库
    static Object getValue(String key) {
        //默认从缓存中获取数据
        Object value = cache.get(key);
        if(value == null) {
            //从数据库中做查询 userBiz.queryRole(1);
            System.out.println("hello zs");
            cache.put(key, new String[] {"zs"});
            return cache.get(key);
        }
        return value;
    }

    public static void main(String[] args) {
        System.out.println(getValue("sname"));
        System.out.println(getValue("sname"));
    }
}

         运行测试：除了第一次是查询了数据库，后面一次就是直接查询的缓存内容；

上面这个就是利用Map做的缓存，主要是体验一下缓存的特点，有着很多的缺陷；

1、不能控制缓存时间；

2、Map集合中不能针对不同数据设置不同的缓存时间。

因此就需要引入一个很强大的缓存框架：Ehcache

        2.4 Ehcache的使用

                2.4.1 导入pom依赖

                        jar包版本管理：

2.10.0
1.7.7

                        jar包依赖： 

     
      net.sf.ehcache
      ehcache
      ${ehcache.version}
    

    
    
      org.slf4j
      slf4j-api
      ${slf4j-api.version}
    
    
      org.slf4j
      jcl-over-slf4j
      ${slf4j-api.version}
      runtime
    

    
    
      org.apache.logging.log4j
      log4j-slf4j-impl
      ${log4j2.version}
    

                2.4.2 导入ehcache.xml文件

    ehcache.xml

关于ehcache配置文件：

核心api对象：

cacheManager：缓存管理器

Cache ：缓存对象

Element：缓存的元素

缓存策略：

1、基于内存，即服务停止，缓存数据丢失

2、基于文件存储

                2.4.3 导入EhcacheUtil类

     EhcacheUtil

package com.leaf.ssm.shiro;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import java.io.InputStream;

public class EhcacheUtil {

    private static CacheManager cacheManager;

    static {
        try {
            InputStream is = EhcacheUtil.class.getResourceAsStream("/ehcache.xml");
            cacheManager = CacheManager.create(is);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private EhcacheUtil() {
    }

    //将缓存数据value 以 key 方式 放入cache中
    public static void put(String cacheName, Object key, Object value) {
        Cache cache = cacheManager.getCache(cacheName);
        if (null == cache) {
            //以默认配置添加一个名叫cacheName的Cache
            cacheManager.addCache(cacheName);
            cache = cacheManager.getCache(cacheName);
        }
        cache.put(new Element(key, value));
    }


    public static Object get(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        if (null == cache) {
            //以默认配置添加一个名叫cacheName的Cache
            cacheManager.addCache(cacheName);
            cache = cacheManager.getCache(cacheName);
        }
        Element element = cache.get(key);
        return null == element ? null : element.getValue();
    }

    public static void remove(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        cache.remove(key);
    }
}

                2.4.4 导入测试类进行测试

     EhcacheDemo2

package com.leaf.ssm.shiro;


/**
 * 演示利用缓存存储数据
 * @author Administrator
 *
 */
public class EhcacheDemo2 {
   public static void main(String[] args) {
      System.out.println(System.getProperty("java.io.tmpdir"));
      /* 读ehcache默认配置 */
//    EhcacheUtil.put("com.leaf.four.entity.Book", 11, "zhangsan");
//    System.out.println(EhcacheUtil.get("com.leaf.four.entity.Book", 11));

      /* 指定硬盘位置 */
      EhcacheUtil.put("com.leaf.one.entity.User", 11, "zhangsan");
      System.out.println(EhcacheUtil.get("com.leaf.one.entity.User", 11));

   }
}

 测试：

我们测试读一个没有配置的缓存条，看看是否会生成到默认的文件夹；

然后我们再测试读我们配置好的缓存条，看看会不会生成到我们指定的硬盘位置；

文件夹里也生成了数据：

结论：

这个案例测试就是说明如果没有定义的缓存条就会执行到默认的缓存条，而指定了缓存生成的硬盘位置的话就会生成到指定的位置。

        2.5 授权使用缓存

                通过前面两个简单案例的测试，我们已经对缓存有了一些小了解，接下来就一起正式敲敲如何在授权的方法中使用，从而解决性能差的问题。

                2.5.1 编写MyRealm的授权方法

     MyRealm

package com.leaf.ssm.shiro;

import com.leaf.ssm.biz.UserBiz;
import com.leaf.ssm.model.User;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.stereotype.Service;

import java.util.Set;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-26 3:37
 */
public class MyRealm extends AuthorizingRealm {

    public UserBiz userBiz;

    public UserBiz getUserBiz() {
        return userBiz;
    }

    public void setUserBiz(UserBiz userBiz) {
        this.userBiz = userBiz;
    }

    /**
     * 授权
     * @param principals
     * @return
     * 替代了昨天的shiro-web.ini
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //拿到账户名
        String userName = principals.getPrimaryPrincipal().toString();

        //先从缓存中取，缓存中没有，再查询数据库，查询出数据就放入缓存
        String cacheName1 = "user:role:"+userName;
        String cacheName2 = "user:per:"+userName;
        //从缓存中获取角色
        Set roleIds = (Set) EhcacheUtil.get(cacheName1, userName);
        //从缓存中获取权限
        Set perIds = (Set) EhcacheUtil.get(cacheName2, userName);

        //判断缓存中是否有信息
        if(roleIds == null || roleIds.size() == 0){
            //调用查询用户角色的方法
            roleIds = userBiz.selectRoleIdsByUserName(userName);
            System.out.println("从数据库中读取用户角色...");
            //放到缓存中
            EhcacheUtil.put(cacheName1,userName,roleIds);
        }
        if(perIds == null || perIds.size() == 0){
            //调用查询用户权限的方法
            perIds = userBiz.selectPerIdsByUserName(userName);
            System.out.println("从数据库中读取用户权限...");
            //放到缓存中
            EhcacheUtil.put(cacheName2,userName,perIds);
        }

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //将当前登录的权限交给shiro的授权器
        info.setStringPermissions(perIds);
        //将当前登录的角色交给shiro的授权器
        info.setRoles(roleIds);
        return info;
    }

    /**
     * 认证
     * @param token
     * @return
     * @throws AuthenticationException
     * 替代了昨天的shiro.ini
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //拿到用户名
        String userName = token.getPrincipal().toString();
        //根据用户名查询到用户对象
        User user = userBiz.queryUserByUserName(userName);
        AuthenticationInfo info = new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                ByteSource.Util.bytes(user.getSalt()),
                this.getName() // realm的名字
        );
        return info;
    }
}

                2.5.2 测试

        登录：

打断点：

第一次登录，查询了数据库：

访问修改密码的方法：

断点直接跳过了查询数据库的代码段，使用缓存中的信息进行授权，访问方法。

OK，授权中使用缓存成功，测试完毕。