Shiro--缓存--使用

红太狼 2022-12-03 05:30 169阅读 0赞

原文网址：[Shiro--缓存--使用\_IT利刃出鞘的博客-CSDN博客\_shiro缓存原理][Shiro--_--_IT_-CSDN_shiro]

# 其他网址 #

> 《跟我学Shiro 》=> 第十一章 缓存
> 
> [Spring--缓存--综述\_IT利刃出鞘的博客-CSDN博客][Spring--_--_IT_-CSDN]

> [使用Shiro和token进行无状态登录-鱼鱼的Java小站][Shiro_token_-_Java]  
> [SpringBoot整合shiro+jwt+redis - 无状态token登录（三）鉴权篇 | 豆腐别馆][SpringBoot_shiro_jwt_redis - _token_ _]
> 
> [实现Shiro的Cache(Redis)功能 | 笔记][Shiro_Cache_Redis_ _]  
> [SpringBoot搭建基于Apache Shiro+Redis的分布式Session共享功能][SpringBoot_Apache Shiro_Redis_Session]  
> [spring boot整合redis实现shiro的分布式session共享\_牛奋lch-CSDN博客][spring boot_redis_shiro_session_lch-CSDN]

# 简介 #

**缓存的实际作用**

> 缓存 Realm 的 doGetAuthorizationInfo() 方法。

**如何使用缓存？**

> 有两种方案。
> 
>  *  **方案1：自己实现shiro缓存**
>  *  **方案2：****使用第三方实现的shiro缓存**  
>     比较出名的是一个shiro-redis第三方框架。  
>     见：[Shiro--实例--SpringBoot--shiro-redis\_IT利刃出鞘的博客-CSDN博客][Shiro--_--SpringBoot--shiro-redis_IT_-CSDN]
> 
> 推荐直接使用这个shiro-redis第三方框架，因为自己实现shiro缓存要考虑的地方特别多：
> 
> 1.  很费时间，手写很多代码。
> 2.  有时候手写的代码有多次不必要地多次更新到Redis的情况。
> 3.  序列化问题。
>     
>     1.  我们可能想用jackson2这个序列化工具，但它有bug，比如：存储没问题，读取总是报错有一个valid字段不识别。然后我们就要用JDK的默认序列化了（Serializable接口），它手写起来也比较费时间

**本文的作用**

> 本文只是大致描述如何自己实现缓存，本文所有代码未经实测，仅供理解大致思路。

# 自己实现缓存 #

**自己实现shiro缓存需要做的**

> 1.  实现org.apache.shiro.cache.Cache接口
> 2.  实现org.apache.shiro.cache.CacheManager
> 3.  注册org.apache.shiro.session.mgt.SessionManager（若用Session）
> 4.  在securityManager里指定Manager
>     
>     1.  指定CacheManager为自己实现的CacheManager

## **1.实现Cache** ##

import org.apache.shiro.cache.Cache;
    import org.apache.shiro.cache.CacheException;
    import org.springframework.data.redis.core.RedisTemplate;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    public class  ShiroCache<K, V> implements Cache<K, V> {
    
        private static final String REDIS_SHIRO_CACHE = "shiro-cache:";
        private static final long GLOB_EXPIRE = 30;
        private String cacheKey;
        private RedisTemplate<K, V> redisTemplate;
        
        public ShiroCache(RedisTemplate<K, V> client, String name) {
            this.cacheKey = REDIS_SHIRO_CACHE + name + ":";
            this.redisTemplate = client;
        }
        
        @Override
        public V get(K key) throws CacheException {
            redisTemplate.boundValueOps(getCacheKey(key))
                         .expire(GLOB_EXPIRE, TimeUnit.MINUTES);
            return redisTemplate.boundValueOps(getCacheKey(key)).get();
        }
        
        @Override
        public V put(K key, V value) throws CacheException {
            V old = get(key);
            redisTemplate.boundValueOps(getCacheKey(key)).set(value);
            return old;
        }
        
        @Override
        public V remove(K key) throws CacheException {
            V old = get(key);
            redisTemplate.delete(getCacheKey(key));
            return old;
        }
        
        @Override
        public void clear() throws CacheException {
            redisTemplate.delete(keys());
        }
        
        @Override
        public int size() {
            return keys().size();
        }
        
        @Override
        public Set<K> keys() {
            return redisTemplate.keys(getCacheKey("*"));
        }
        
        @Override
        public Collection<V> values() {
            Set<K> set = keys();
            List<V> list = new ArrayList<>();
            for (K s : set) {
                list.add(get(s));
            }
            return list;
        }
        
        private K getCacheKey(Object k) {
            return (K) (this.cacheKey + k);
        }
    }

## **2.实现CacheManager** ##

import com.goku.webapi.config.Shiro.ShiroCache;
    import org.apache.shiro.cache.AbstractCacheManager;
    import org.apache.shiro.cache.Cache;
    import org.apache.shiro.cache.CacheException;
    import org.springframework.data.redis.core.RedisTemplate;
    public class RedisCacheManager extends AbstractCacheManager {
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        @Override
        protected Cache<String, Object> createCache(String name) throws CacheException {
            return new ShiroCache<>(redisTemplate, name);
        }
    }

## 3.在securityManager里指定Manager ##

@Configuration
    public class ShiroConfig {
        // 名字必须是securityManager
        @Bean(name = "securityManager")
        public SessionsSecurityManager securityManager() {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            //支持缓存
            securityManager.setCacheManager(自己的CacheManager);
            //securityManager.setSessionManager(sessionManager());
            securityManager.setRealm(getDatabaseRealm());
            return securityManager;
        }
        
        //省略其他配置
    }

# 自己实现session缓存 #

**自己实现shiro的session缓存需要做的**

> 1.  继承下边的任意一个类
>     
>     1.  org.apache.shiro.session.mgt.eis.AbstractSessionDAO
>     2.  org.apache.shiro.session.mgt.eis.CachingSessionDAO
>     3.  org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO
> 2.  注册org.apache.shiro.session.mgt.SessionManager
> 3.  在securityManager里指定Manager
>     
>     1.  指定SessionManager为自己注册的CacheManager

##  **1.继承SessionDAO** ##

>     import java.io.Serializable;
>     import java.util.Collection;
>     import java.util.concurrent.TimeUnit;
>      
>     import org.apache.shiro.session.Session;
>     import org.apache.shiro.session.UnknownSessionException;
>     import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
>     import org.springframework.beans.factory.annotation.Autowired;
>     import org.springframework.data.redis.core.RedisTemplate;
>     import org.springframework.stereotype.Service;
>      
>     @Service
>     @SuppressWarnings({ "rawtypes", "unchecked" })
>     public class RedisSessionDao extends AbstractSessionDAO {
>      
>     	// Session超时时间，单位为毫秒
>     	private long expireTime = 120000;
>      
>     	@Autowired
>     	private RedisTemplate redisTemplate;// Redis操作类，对这个使用不熟悉的，可以参考前面的博客
>      
>     	public RedisSessionDao() {
>     		super();
>     	}
>      
>     	public RedisSessionDao(long expireTime, RedisTemplate redisTemplate) {
>     		super();
>     		this.expireTime = expireTime;
>     		this.redisTemplate = redisTemplate;
>     	}
>      
>     	@Override // 更新session
>     	public void update(Session session) throws UnknownSessionException {
>     		System.out.println("===============update================");
>     		if (session == null || session.getId() == null) {
>     			return;
>     		}
>     		session.setTimeout(expireTime);
>     		redisTemplate.opsForValue().set(session.getId(), session, expireTime, TimeUnit.MILLISECONDS);
>     	}
>      
>     	@Override // 删除session
>     	public void delete(Session session) {
>     		System.out.println("===============delete================");
>     		if (null == session) {
>     			return;
>     		}
>     		redisTemplate.opsForValue().getOperations().delete(session.getId());
>     	}
>      
>     	@Override// 获取活跃的session，可以用来统计在线人数，如果要实现这个功能，可以在将session加入redis时指定一个session前缀，统计的时候则使用keys("session-prefix*")的方式来模糊查找redis中所有的session集合
>     	public Collection<Session> getActiveSessions() {
>     		System.out.println("==============getActiveSessions=================");
>     		return redisTemplate.keys("*");
>     	}
>      
>     	@Override// 加入session
>     	protected Serializable doCreate(Session session) {
>     		System.out.println("===============doCreate================");
>     		Serializable sessionId = this.generateSessionId(session);
>     		this.assignSessionId(session, sessionId);
>      
>     		redisTemplate.opsForValue().set(session.getId(), session, expireTime, TimeUnit.MILLISECONDS);
>     		return sessionId;
>     	}
>      
>     	@Override// 读取session
>     	protected Session doReadSession(Serializable sessionId) {
>     		System.out.println("==============doReadSession=================");
>     		if (sessionId == null) {
>     			return null;
>     		}
>     		return (Session) redisTemplate.opsForValue().get(sessionId);
>     	}
>      
>     	public long getExpireTime() {
>     		return expireTime;
>     	}
>      
>     	public void setExpireTime(long expireTime) {
>     		this.expireTime = expireTime;
>     	}
>      
>     	public RedisTemplate getRedisTemplate() {
>     		return redisTemplate;
>     	}
>      
>     	public void setRedisTemplate(RedisTemplate redisTemplate) {
>     		this.redisTemplate = redisTemplate;
>     	}
>     }

## **2.注册**SessionManager ##

@Bean
    public SessionManager sessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionDAO(sessionDAO());
        sessionManager.setGlobalSessionTimeout(1800);
        //sessionManager.setCacheManager(redisCacheManager());
        return sessionManager;
    }

## 3.在securityManager里指定Manager ##

@Configuration
    public class ShiroConfig {
        // 名字必须是securityManager
        @Bean(name = "securityManager")
        public SessionsSecurityManager securityManager() {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            //支持缓存
            //securityManager.setCacheManager(自己的CacheManager);
            securityManager.setSessionManager(sessionManager());
            securityManager.setRealm(getDatabaseRealm());
            return securityManager;
        }
        
        //省略其他配置
    }

[Shiro--_--_IT_-CSDN_shiro]: https://knife.blog.csdn.net/article/details/108355330
[Spring--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/119548256
[Shiro_token_-_Java]: https://www.fishmaple.cn/blog/d?bid=15469435979e7f8a0aee274568a533d0e306f2154f
[SpringBoot_shiro_jwt_redis - _token_ _]: https://www.doufuplus.com/blog/shiro-jwt03.html
[Shiro_Cache_Redis_ _]: https://note.dolyw.com/shirojwt/ShiroJwt04-Redis.html
[SpringBoot_Apache Shiro_Redis_Session]: https://www.shuzhiduo.com/A/A2dmwpYqJe/
[spring boot_redis_shiro_session_lch-CSDN]: https://blog.csdn.net/liuchuanhong1/article/details/76690682
[Shiro--_--SpringBoot--shiro-redis_IT_-CSDN]: https://knife.blog.csdn.net/article/details/119723197