Shiro 学习 08 - 集成 Spring 之授权缓存

博主： zhaojun
发布时间：2022 年 05 月 02 日
1766 次浏览
暂无评论
4972字数
分类：默认分类

## 前言

在 [手撸 Java Web RBAC 权限管理](http://www.zhaojun.im/java-permission-1/) 中，我们自己实现了一个简易的 RBAC 权限管理框架，且我们也提到了一些缺陷，其中一点就是 :  **每次请求需要授权的页面都会去数据库查询此用户对应的权限数据和角色数据，太耗费资源，应该进行缓存。**

本章我们就来讲讲如何将 Shiro 中的授权数据缓存到 Redis 中。

## API

Shiro 为授权数据的缓存提供了两个借口，一个是 `CacheManager`，一个是 `Cache`。

根据这两个接口，我们完全可以将授权数据缓存到任何地方，包括 `redis`、`ehcache` 、内存等。

## Redis

既然我们要缓存到 Redis 中，我们需要搭建 Redis 环境，并导入 Redis 工具类：

```xml
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
```

新建配置文件 `spring-redis.xml`：

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        
        <property name="maxTotal" value="500"/>
        
        <property name="maxIdle" value="100"/>
        
        <property name="minIdle" value="10"/>
        
        <property name="maxWaitMillis" value="5000"/>
        
        <property name="testOnBorrow" value="true"/>
    </bean>
</beans>
```

## Cache

我们来创建一个 `RedisCache` 继承自 `org.apache.shiro.cache.Cache`，来实现它的方法：

```java
package im.zhaojun.cache;

import im.zhaojun.util.JedisUtil;
import org.apache.log4j.Logger;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.springframework.stereotype.Component;
import org.springframework.util.SerializationUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.Set;

@Component
public class RedisCache<K, V> implements Cache<K, V> {

private static final Logger logger = Logger.getLogger(RedisCache.class);

@Resource
    private JedisUtil jedisUtil;

private final String CACHE_PREFIX = "shiro-cache:";

private byte[] getKeyBytes(K k) {
        return (CACHE_PREFIX + k).getBytes();
    }

@Override
    public V get(K k) throws CacheException {
        logger.info("从 Redis 中读取授权信息...");
        byte[] key = getKeyBytes(k);
        byte[] value = jedisUtil.get(key);
        if (value != null) {
            return (V) SerializationUtils.deserialize(value);
        }
        return null;
    }

@Override
    public V put(K k, V v) throws CacheException {
        byte[] key = getKeyBytes(k);
        byte[] value = SerializationUtils.serialize(v);
        jedisUtil.set(key, value);
        jedisUtil.expire(key, 600);
        return v;
    }

@Override
    public V remove(K k) throws CacheException {
        byte[] key = getKeyBytes(k);
        byte[] value = jedisUtil.get(key);
        jedisUtil.del(key);

if (value != null) {
            SerializationUtils.deserialize(value);
        }
        return null;
    }

@Override
    public void clear() throws CacheException {
        jedisUtil.delKeysByPrefix(CACHE_PREFIX);
    }

@Override
    public int size() {
        return jedisUtil.getKeysByPrefix(CACHE_PREFIX).size();
    }

@Override
    public Set<K> keys() {
        return (Set<K>) jedisUtil.getKeysByPrefix(CACHE_PREFIX);
    }

@Override
    public Collection<V> values() {
        return jedisUtil.getValuesByPrefix(CACHE_PREFIX);
    }
}
```

其中没什么难点，只是对 redis 的基本增删改查操作，由于是存储到 redis 中，所以我们为缓存数据的 key 添加了前缀，以便再次获取。

## CacheManager

我们创建一个 `RedisCacheManager` 类来继承自 `org.apache.shiro.cache.AbstractCacheManager`，当然你也可以直接继承自 `org.apache.shiro.cacheCacheManager`：

```java
package im.zhaojun.cache;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.AbstractCacheManager;

import javax.annotation.Resource;

@Component
public class RedisCacheManager extends AbstractCacheManager  {

@Resource
    private RedisCache redisCache;

@Override
    protected Cache createCache(String s) throws CacheException {
        return redisCache;
    }
}
```

这里在 `createCache() ` 方法中返回我们的自定义 `RedisCache` 对象即可。

## Spring

然后我们将 `RedisCacheManager` 配置到 `securityManager` 中：

```xml
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <property name="realm" ref="myRealm"/>
    <property name="cacheManager" ref="redisCacheManager"/>
</bean>
```

以及将 `spring-redis.xml` 配置到 `web.xml` 中：

```xml
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:spring.xml,
        classpath:spring-shiro.xml,
        classpath:spring-redis.xml
    </param-value>
</context-param>
```

## Test

然后我们分别在 `Realm` 的 `doGetAuthorizationInfo` 方法和 `RedisCache` 的 `get` 方法中分别打印一条日志，看何时会访问数据库，何时会访问 `Redis` 缓存的数据。

* 首先是未认证的情况下，访问需要权限的的页面，不会输出任何信息，因为需要认证后，才会根据认证信息去获取授权现象，没有认证时，会直接拦截。
* 认证之后，访问需要授权的页面，会输入如下信息：
  
  ```java
  im.zhaojun.cache.RedisCache 15:09:14,015  INFO RedisCache:30 - 从 Redis 中读取授权信息...
  im.zhaojun.realm.MyRealm 15:09:14,016  INFO MyRealm:23 - 从数据库中读取授权信息...
  ```
  
  由此可见，Shiro 会先去 Redis 中取数据，如果 Redis 中没有，再去 Realm(数据库) 中取。
  然后再次访问这个页面，输入：
  
  ```java
  im.zhaojun.cache.RedisCache 15:11:13,351  INFO RedisCache:30 - 从 Redis 中读取授权信息...
  ```
  
  因为缓存中已经有了，就不再去数据库中查询了。

## 小结

其实频繁从 Redis 中读取也是比较浪费资源的， Redis 的连接同样宝贵，最好的办法还是直接存储在内存中，但也是各有利弊，需要根据实际项目来决定使用哪种方案。

> 放到 Redis 的好处是：可以用来做跨项目/机器的数据缓存，可以集群，持久化等。
> 
> 放到内存的好处是：速度快，使用方便快捷。
> 
> **但使用这种缓存还有一个比较重要的事情，就是当数据库中的授权数据发生修改时，也要记得刷新缓存中的数据，不然会出现数据错乱，实现方式可以通过直接覆盖缓存，消息队列通知等方式，需要根据不同项目来选区不同方式，由于篇幅原因这里不再展开讲了。**

本章代码地址 : https://github.com/zhaojun1998/Premission-Study/tree/master/Permission-Shiro-08/

最后修改：2022 年 05 月 02 日

如果觉得我的文章对你有用，请我喝杯咖啡吧。

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

天天下载
学习了，谢谢 http://appdo...
聊应用
来留个脚印。
快帆云
你好，我们的机场：快帆云，已经稳定运营三年多，现在诚邀推广员。...
在nginx层面给任意项目站点增加访问限制：casdoor+oauth2-proxy - Blog By chenchen.site
[...]如果是宝塔用户可以直接使用以下方法安装模块，参考文章...
大概
你好，我就想整一个网盘，用作知识付费，就是普通用户只可以看到标...

Shiro 学习 08 - 集成 Spring 之授权缓存

zhaojun • 2022 年 05 月 02 日