3_springboot_shiro_jwt_多端认证鉴权_Redis缓存管理器

paopao_wu

已于 2024-03-16 15:05:17 修改

阅读量767

点赞数 21

分类专栏： Shiro与JWT 文章标签：缓存 spring boot redis shiro，jwt

于 2024-03-13 14:10:51 首次发布

本文链接：https://blog.csdn.net/paopao_wu/article/details/136678406

版权

Shiro与JWT 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 什么是Shiro缓存管理器

上一章节分析完了Realm是怎么运作的，自定义的Realm该如何写，需要注意什么。本章来关注Realm中的一个话题，缓存。再看看 AuthorizingRealm 类继承关系
在这里插入图片描述
其中抽象类 CachingRealm ，表示这个Realm是带缓存的，那什么东西是需要缓存的？

我们说Realm主要是提供认证信息（org.apache.shiro.authc.AuthenticationInfo 含有身份信息和凭证信息）和授权信息的（org.apache.shiro.authz.AuthorizationInfo 含有角色，权限信息）这些信息往往会存储到数据库中。当用户频繁访问系统的时候，SecurityManager 就需要从Realm中获取认证信息和授权信息来对当前的访问进行认证和鉴权，这样就会频繁操作数据库。为了提高性能，我们可以将这两个信息缓存起来，下次再需要的时候，直接从缓存中获取，而无需再次调用Reaml来获取。

2. 默认缓存管理器

可以看到在 org.apache.shiro.realm.CachingRealm 类中有一个 org.apache.shiro.cache.CacheManager 它是一个接口，即缓存管理器。既然是缓存管理器，就是说它可以对缓存进行管理。那 Realm 默认情况下使用的是哪个具体的CacheManager实现？

查阅 AuthorizingRealm 源码，发现CacheManager 是后set进来的。那什么时候set进来的？

上一章节介绍了 SecurityManager 的实例化，它是通过SpringBoot 的自动配置实例化出来的。通过跟踪源码，看到了如下代码：

org.apache.shiro.spring.config.AbstractShiroConfiguration

public class AbstractShiroConfiguration {
	// 只需要在Spring 容器中配置一个 bean,就会被注入进来
    @Autowired(required = false)
    protected CacheManager cacheManager;

    protected SessionsSecurityManager securityManager(List<Realm> realms) {
        SessionsSecurityManager securityManager = createSecurityManager();
        ...
        securityManager.setRealms(realms);
        ...
        if (cacheManager != null) {
            securityManager.setCacheManager(cacheManager);
        }

        return securityManager;
    }
}

在 securityManager.setRealms(realms); 这个方法的内部看到执行了一个方法applyCacheManagerToRealms(), 这个方法会找到系统中所有的realm ，然后依次将 cacheManager配置到realm中。

而且 securityManager 中使用的CacheManager 和 realm中使用的是同一个缓存管理器。

那要找到默认的缓存管理器，就要看看自动配置中有没有配置CacheManager，经过一番查找，并没有找到。也就是说Shiro框架默认是不带缓存的。为了证实想法，可以在前面 SystemAccountRealm 的 doGetAuthenticationInfo 方法中获取 CacheManager,然后判断它是否为空：

public class SystemAccountRealm extends AuthorizingRealm {
    ...
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        if (getCacheManager() == null) {
            log.debug("================>cacheManager为空");
        } else {
            log.debug("================cacheManager:{}", getCacheManager().getClass().getName());
        }
        ...
    }
}

启动应用后进行登录，发现CacheManager果然为空。

3. Shiro Cache与CacheManager

Shiro对 Cache和 CacheManager做了规范，并提供了简单实现
在这里插入图片描述

MapCache 其实就使用Map来存储数据，将数据缓存到内存中。

MemoryConstrainedCacheManager 就是内存缓存管理器

如果是单机应用，完全可以使用内存来作为缓存。但对于分布式集群化部署的应用，如果还是使用内存，那就会造成数据的不一致。

本章节使用Redis作为Shiro的 Cache。官方并没有提供Redis缓存的实现，所以需要我们自己实现 Cache和 CacheManager接口。

4. 使用Redis作为ShiroCache

请自行准备Redis服务器。这里使用本机上安装的Redis服务。

4.1 引入spring-boot-starter-data-redis

SpringBoot官方有一个 starter，提供了对Redis的访问。首先在xml中引入：

pom.xml

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

在application.properties 文件中配置redis服务器参数：

...
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123456
...

4.2 自己实现shiro Cache规范

要想用redis作为shiro的 cache，那么就需要自己来实现Cache和CahceManager

ShiroRedisCache.java

package com.qinyeit.shirojwt.demos.shiro.cache;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Collection;
import java.util.Set;
// 其实就是对数据进行存，取，清除，删除
public class ShiroRedisCache<K, V> implements Cache<K, V> {
    private RedisTemplate redisTemplate;
    private String        cacheName;

    public ShiroRedisCache(RedisTemplate redisTemplate, String cacheName) {
        this.redisTemplate = redisTemplate;
        this.cacheName = cacheName;
    }

    @Override
    public V get(K key) throws CacheException {
        // 取hash中的值
        return (V) redisTemplate.opsForHash().get(this.cacheName, key.toString());
    }

    @Override
    public V put(K key, V value) throws CacheException {
        redisTemplate.opsForHash().put(this.cacheName, key.toString(), value);
        return value;
    }

    @Override
    public V remove(K key) throws CacheException {
        return (V) redisTemplate.opsForHash().delete(this.cacheName, key.toString());
    }

    @Override
    public void clear() throws CacheException {
        redisTemplate.delete(this.cacheName);
    }

    @Override
    public int size() {
        return redisTemplate.opsForHash().size(this.cacheName).intValue();
    }

    @Override
    public Set<K> keys() {
        return redisTemplate.opsForHash().keys(this.cacheName);
    }

    @Override
    public Collection<V> values() {
        return redisTemplate.opsForHash().values(this.cacheName);
    }
}

ShiroRedisCacheManager.java 缓存管理器

package com.qinyeit.shirojwt.demos.shiro.cache;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.springframework.data.redis.core.RedisTemplate;
public class ShiroRedisCacheManager implements CacheManager {
    private RedisTemplate redisTemplate;

    public ShiroRedisCacheManager(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // 这个方法由Shiro框加来调用，当需要用到缓存的时候，就会传入缓存的名字，比如我们可以为
    // 认证信息缓存，为“authenticationCache”；为授权信息缓存，为“authorizationCache”；为“sessionCache”等
    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        // 自动去RedisCahce中找具体实现
        return new ShiroRedisCache<K, V>(redisTemplate, name);
    }
}

4.3 开启缓存

从前面的分析知道，只需要将缓存管理器注册为SpringBean，就会自动注入到 securityManager 中。

引入了 spring-boot-starter-data-redis 之后，自动配置会创建 org.springframework.data.redis.core.RedisTemplate 这个bean，我们将他配置到Shiro的CacheManager中：

第8-19行，配置realm开启认证和授权数据缓存，并给缓存设置了名字。稍后我们可以到Redis中检查是否缓存成功
第23-26行配置了自定义的 ShiroRedisCacheManager ,它需要 RedisTemplate 才能工作。

package com.qinyeit.shirojwt.demos.configuration;
...
@Configuration
@Slf4j
public class ShiroConfiguration {
    @Bean
    public Realm realm() {
        SystemAccountRealm realm = new SystemAccountRealm();
        // 开启全局缓存
        realm.setCachingEnabled(true);
        // 打开认证缓存
        realm.setAuthenticationCachingEnabled(true);
        // 认证缓存的名字，不设置也可以，默认由
        realm.setAuthenticationCacheName("shiro:authentication：cache");

        // 打开授权缓存
        realm.setAuthorizationCachingEnabled(true);
        // 授权缓存的名字， 不设置也可以，默认由
        realm.setAuthorizationCacheName("shiro:authorization：cache");
        return new SystemAccountRealm();
    }
	// 创建Shiro 的 CahceManager
    @Bean
    public CacheManager shiroCacheManager(RedisTemplate redisTemplate) {
        return new ShiroRedisCacheManager(redisTemplate);
    }

    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {...}

    @Bean
    public FilterRegistrationBean<AuthenticationFilter> customShiroFilterRegistration(ShiroFilterFactoryBean shiroFilterFactoryBean) { ... }
}

4.4 Redis序列化错误

此时启动应用，执行登录。前面我们在SystemAccountRealm.doGetAuthenticationInfo 方法中添加了打印日志，可以看到 cacheManager已经配置成了我们自定义的com.qinyeit.shirojwt.demos.shiro.cache.ShiroRedisCacheManager ，但是后续的执行中报错了：

org.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using DefaultSerializer; nested exception is java.io.NotSerializableException: org.apache.shiro.lang.util.SimpleByteSource

意思是，Redis尝试将对象序列化到Redis中的时候，遇到了一个不可序列化的对象org.apache.shiro.lang.util.SimpleByteSource。

跟踪源码：

自定义的 SystemAccountRealm 中的 doGetAuthenticationInfo 是在哪里调用的？这个方法在其父类中被定义为抽象方法，那么它应该是在父类 AuthenticationRealm 中被调用的,下面代码的第 6行就是：

public final AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		// 从缓存中获取认证信息
        AuthenticationInfo info = getCachedAuthenticationInfo(token);
    	// 缓存中没有，则调用 子类 Realm中的 doGetAuthenticationInfo 方法
        if (info == null) {
            info = doGetAuthenticationInfo(token);
            // 如果获取到了 认证信息，则进行缓存
            if (token != null && info != null) {
                cacheAuthenticationInfoIfPossible(token, info);
            }
        } else {
            LOGGER.debug("Using cached authentication info [{}] to perform credentials matching.", info);
        }

        if (info != null) {
            // 调用匹配器进行匹配
            assertCredentialsMatch(token, info);
        } else {
            LOGGER.debug("No AuthenticationInfo found for submitted AuthenticationToken [{}].  Returning null.", token);
        }
        return info;
    }

继续跟踪 cacheAuthenticationInfoIfPossible 方法：

    private void cacheAuthenticationInfoIfPossible(AuthenticationToken token, AuthenticationInfo info) {
        if (!isAuthenticationCachingEnabled(token, info)) {
            LOGGER.debug("AuthenticationInfo caching is disabled for info [{}].  Submitted token: [{}].", info, token);
            //return quietly, caching is disabled for this token/info pair:
            return;
        }

        Cache<Object, AuthenticationInfo> cache = getAvailableAuthenticationCache();
        if (cache != null) {
            // 获取缓存的Redis中的Hash key . 注意这个key 不是Redis 的key ，Reidskey实际是缓存的名字， 而这里的key是 redis Hash数据结构中的key。 查看自定义的 ShiroRedisCache 的 put方法就不难理解
            Object key = getAuthenticationCacheKey(token);
            // 缓存 info, 这里实际上就是在从 Reaml 中 的 doGetAuthenticationInfo 方法返回的 SimpleAuthenticationInfo
            // 到这里就交个 CacheManager去缓存了
            cache.put(key, info);
            LOGGER.trace("Cached AuthenticationInfo for continued authentication.  key=[{}], value=[{}].", key, info);
        }
    }

所以自定义的ShiroRedisCache向Redis中缓存的数据是一个 Redis Hash， Redis key为：shiro:authentication：cache , Redis Hash 中的key 为：
 protected Object getAuthenticationCacheKey(AuthenticationToken token) {
        return token != null ? token.getPrincipal() : null;
 }
就是token中的认证主体，就是用户名。因为AuthenticationToken 的实际类型是 UsernamePasswordToken ， getPrincipal() 返回的是用户名

value就是从 Reaml 中的 doGetAuthenticationInfo 方法返回的 SimpleAuthenticationInfo

至此可以总结出Shiro在 Redis中缓存的数据结构：
在这里插入图片描述

注意：

认证相关的单词： AuthenticationInfo , SimpleAuthenticationInfo

授权相关的单词：AuthorizationInfo , SimpleAuthorizationInfo

很相似，比较容易搞混淆。当然他们都可以自定义

SimpleAuthenticationInfo 中就包含了 SimpleByteSource 类型，默认的序列化器无法完成序列化，所以就需要我们自定义Redis的序列化器

4.5 解决序列化错误

为什么SimpleByteSource 无法完成序列化？看看它的定义：

package org.apache.shiro.lang.util;
...
public class SimpleByteSource implements ByteSource {
    ...
}

它没有实现 java.io.Serializable 即序列化接口。而系统 RedisTemplate 中默认的序列化器为 JdkSerializationRedisSerializer ，也就是说要序列化的数据全部都需要实现 java.io.Serializable 接口才行。

所以要解决这个序列化错误就有两种办法：

自定义Shiro的ByteSource
自定义RedisTemplate中的序列化器

对于两种方案，第一种是最简单的，第二种麻烦一点，大家可以自行百度。

4.5.1 自定义ByteSource 实现Serializable接口

在来看看 SimpleAuthenticationInfo 中的代码.

public class SimpleAuthenticationInfo implements MergableAuthenticationInfo, SaltedAuthenticationInfo {
    ...
    protected ByteSource credentialsSalt = SimpleByteSource.empty();

    public SimpleAuthenticationInfo(Object principal, Object hashedCredentials, ByteSource credentialsSalt, String realmName) {
        this.principals = new SimplePrincipalCollection(principal, realmName);
        this.credentials = hashedCredentials;
        this.credentialsSalt = credentialsSalt;
    }
    ...
    @Override
    public ByteSource getCredentialsSalt() {
        return credentialsSalt;
    }
    ...
    public void setCredentialsSalt(ByteSource salt) {
        this.credentialsSalt = salt;
    }
    ...
}

credentialsSalt 其实就是盐值的凭证，它可以通过构造方法传入，也可以通过set方法传入，所以我们只需要定义个子类继承 SimpleByteSource，然后实现Serializable接口即可。下面是代码：

package com.qinyeit.shirojwt.demos.shiro.realm;
...
package com.qinyeit.shirojwt.demos.shiro.realm;
...
//继承SimpleByteSource，然后实现 Serializable接口, 仿照SimpleByteSource 中代码实现
//添加一个无参构造方法，反序列化的时候会用到，要不然依然会报错
public class SaltSimpleByteSource extends CodecSupport implements ByteSource, Serializable {
    private byte[] bytes;
    private String cachedHex;
    private String cachedBase64;

    // 添加一个无参构造函数，反序列化会用到
    public SaltSimpleByteSource() {
    }

    public SaltSimpleByteSource(byte[] bytes) {
        this.bytes = bytes;
    }

    public SaltSimpleByteSource(char[] chars) {
        this.bytes = toBytes(chars);
    }

    public SaltSimpleByteSource(String string) {
        this.bytes = toBytes(string);
    }

    public SaltSimpleByteSource(ByteSource source) {
        this.bytes = source.getBytes();
    }

    public SaltSimpleByteSource(File file) {
        this.bytes = toBytes(file);
    }

    public SaltSimpleByteSource(InputStream stream) {
        this.bytes = toBytes(stream);
    }

    @Override
    public byte[] getBytes() {
        return bytes;
    }

    @Override
    public String toHex() {
        if (this.cachedHex == null) {
            this.cachedHex = Hex.encodeToString(this.getBytes());
        }

        return this.cachedHex;
    }

    @Override
    public String toBase64() {
        if (this.cachedBase64 == null) {
            this.cachedBase64 = Base64.encodeToString(this.getBytes());
        }
        return this.cachedBase64;
    }

    public String toString() {
        return this.toBase64();
    }

    public int hashCode() {
        return this.bytes != null && this.bytes.length != 0 ? Arrays.hashCode(this.bytes) : 0;
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (o instanceof ByteSource) {
            ByteSource bs = (ByteSource) o;
            return Arrays.equals(this.getBytes(), bs.getBytes());
        } else {
            return false;
        }
    }

    @Override
    public boolean isEmpty() {
        return this.bytes == null || this.bytes.length == 0;
    }
}

4.5.2 在Realm中使用自定义的SaltSimpleByteSource

将 Reaml中返回SimpleAuthenticationInfo 中的 ByteSource替换成我们自己的 SaltSimpleByteSource

package com.qinyeit.shirojwt.demos.shiro.realm;
...
@Slf4j
public class SystemAccountRealm extends AuthorizingRealm {
    ...
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        if (getCacheManager() == null) {
            log.info("================>cacheManager为空");
        } else {
            log.info("================cacheManager:{}", getCacheManager().getClass().getName());
        }
        // 1.从传过来的认证Token信息中，获得账号
        String account = token.getPrincipal().toString();

        // 2.通过用户名到数据库中获取整个用户对象
        SystemAccount systemAccount = systemAccountMap.get(account);
        if (systemAccount == null) {
            throw new UnknownAccountException();
        }
        // 3. 创建认证信息，即用户正确的用户名和密码。
        // 四个参数：
        
        // 第一个参数为主体，第二个参数为凭证，第三个参数为Realm的名称
        // 因为上面将凭证信息和主体身份信息都保存在 SystemAccount中了，所以这里直接将 SystemAccount对象作为主体信息即可

        // 第二个参数表示凭证，匹配器中会从 SystemAccount中获取盐值，密码登凭证信息，所以这里直接传null。

        // 第三个参数，表示盐值，这里使用了自定义的SaltSimpleByteSource，之所以在这里new了一个自定义的SaltSimpleByteSource，
        // 是因为开启redis缓存的情况下，序列化会报错
        
        // 第四个参数表示 Realm的名称
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                systemAccount,
                null,
                new SaltSimpleByteSource(systemAccount.getSalt()),
                getName()
        );
        // authenticationInfo.setCredentialsSalt(null);
        return authenticationInfo;
    }
    ...    
}

4.6 查看Redis 中的key

做如下操作后查看Redis服务器中的key:

登录

登录执行完毕之后，就会对认证信息 AuthenticationInfo 进行缓存
访问home

访问home的时候，会调用Reaml中的doGetAuthenticationInfo 方法获取认证信息，此时因为缓存中已经有了认证信息，所以直接从缓存中获取。home页面需要鉴权才能访问，所以第一次会调用Reaml中的doGetAuthorizationInfo 方法获取鉴权信息，然后放入到缓存中。

4.7 Key前面的16进制字符是什么？

我们发现Redis 中的key前面有几个16进制的字符，这是为什么？这还是因为RedisTemplate 中使用的序列化器使用的都是默认的 JdkSerializationRedisSerializer , 它将所有的key都当成Object来进行序列化。我们可以将与key相关的序列化器配置成 StringRedisSerializer ，前面的16进制字符就消失了。

RedisTemplate 中有如下的序列化器可以配置：

keySerializer： redis key序列化器
valueSerializer： redis value 序列化器
hashKeySerializer: reids Hash 结构中的key的序列化器
hashValueSerializer: redis Hash 结构中的value的序列化器

下面将 RedisTemplate 中的 keySerializer，和 hashKeySerializer 指定为 StringRedisSerializer：

package com.qinyeit.shirojwt.demos.configuration;
...
@Configuration
@Slf4j
public class ShiroConfiguration {
    ...
     @Bean
    public CacheManager shiroCacheManager(RedisTemplate redisTemplate) {
        RedisSerializer<String> stringSerializer = RedisSerializer.string();
        // 设置key的序列化器
        redisTemplate.setKeySerializer(stringSerializer);
        // 设置 Hash 结构中 key 的序列化器
        redisTemplate.setHashKeySerializer(stringSerializer);
        return new ShiroRedisCacheManager(redisTemplate);
    }    
    ...
}

修改完毕之后，就看起来正常了：
在这里插入图片描述

4.8 缓存什么时候清除

在CachingRealm中，找到了如下代码：

public abstract class CachingRealm implements Realm, Nameable, CacheManagerAware, LogoutAware {
	// LogoutAware 接口中定义的方法，当Subject 调用退出的时候，会委托securityManager来调用这个方法
    // 此时就会将当前登录用户的 缓存清理掉
    public void onLogout(PrincipalCollection principals) {
        clearCache(principals);
    }
    ...
    protected void clearCache(PrincipalCollection principals) {
        if (!isEmpty(principals)) {
            doClearCache(principals);
            LOGGER.trace("Cleared cache entries for account with principals [{}]", principals);
        }
    }
    // 实际执行的时候，会调用子类中重写的方法
    protected void doClearCache(PrincipalCollection principals) {
    }
    ...
}

在这里插入图片描述
可以看到， AuthenticationRealm 和 AuthorizingRealm 中都重写了这个方法，所以退出的时候会清理掉认证信息和授权信息

5. 总结

缓存管理器主要缓存 Reaml中返回的认证信息和授权信息
Shiro自动配置中没有配置缓存管理器。
自定义Shiro Redis Cache 缓存管理器步骤：
- 实现 Shiro Cachce接口 org.apache.shiro.cache.Cache
- 实现Shiro CacheManager接口 org.apache.shiro.cache.CacheManage
- 在配置中将自定义的CacheManager配置成Spring Bean
- 在Reaml中开启缓存
- Shiro中的org.apache.shiro.lang.util.SimpleByteSource 没有实现序列化接口，所以RedisTemplate序列化的时候由于采用的是 JdkSerializationRedisSerializer ，这样会报错。所以要自定义 SimpleByteSource ，实现序列化接口即可解决这个问题
登录或者认证的时候，都会调用Realm的 doGetAuthenticationInfo 方法，此时会使用配置的缓存管理器来缓存认证信息数据
鉴权的时候，会调用 Realm 的 doGetAuthorizationInfo方法，此时会调用配置的缓存管理器来缓存鉴权数据。
退出的时候，会清理当前用户下的认证和鉴权数据信息。

代码仓库 https://github.com/kaiwill/shiro-jwt ，本节代码在 3_springboot_shiro_jwt_多端认证鉴权_Redis缓存管理器分支上.

paopao_wu

关注

21
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
3_springboot_shiro_jwt_多端认证鉴权_Redis缓存管理器

本章介绍什么是Shiro的缓存管理器，作用是什么，自定义Redis Shiro缓存管理器。缓存什么时候被创建，缓存的内容是什么，什么时候过期
复制链接

扫一扫