【Shiro】3.Springboot实现缓存

最近已经快速入门了Shiro。对于登录、授权、认证等方法，每次都是从数据库直接查询。如果登录的人员过多，对数据库来说，是一项压力。如何减轻数据库的压力。

• EhCache 实现缓存
• 集成 Redis 实现 Shiro 缓存（推荐使用）

在此之前，我们已经简单学会EhCache 和Reids的使用。

EhCache 实现缓存

Shiro 提供了缓存管理器，这样在用户第一次认证授权后访问其受限资源的时候就不用每次查询数据库从而达到减轻数据压力的作用，使用 Shiro 的缓存管理器也很简单。第一步，在pom.xml引入依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.13.10</version>
</dependency>

ShiroConfiguratin 添加缓存配置：

/**
 * 3.创建自定义realm
 * @return
 */
@Bean
public Realm getRealm(){
    UserRealm userRealm = new UserRealm();
    // 设置缓存管理器
    userRealm.setCacheManager(new EhCacheManager());
    // 开启全局缓存
    userRealm.setCachingEnabled(true);
    // 开启认证缓存并指定缓存名称
    userRealm.setAuthenticationCachingEnabled(true);
    userRealm.setAuthenticationCacheName("authenicationCache");
    // 开启缓存授权并指定缓存名称
    userRealm.setAuthorizationCachingEnabled(true);
    userRealm.setAuthorizationCacheName("authenicationCache");
    return userRealm;
}

这样就将 EhCache 集成进来了，但是 shiro 的这个缓存是本地缓存，也就是说当程序宕机重启后仍然需要从数据库加载数据，不能实现分布式缓存的功能。

集成 Redis 实现 Shiro 缓存（推荐使用）

已知Redis的使用，我们实现了Redis的引用和配置。

在pom.xml文件引入Redis依赖

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

配置RedisConfig

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * RedisTemplate相关配置
     * 使redis支持插入对象
     *
     * @param factory
     * @return 方法缓存 Methods the cache
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        // 序列化 key 和hashKey采用String序列化；value和hashValue采用JSON序列化
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // value和hashvalue采用JSON序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        return template;
    }
}

配置redis的数据库连接，这里以application.yml为例

spring:
  redis:
    database: 0     # 数据库索引，默认为0
    host: 127.0.0.1 # redis地址
    port: 6379      # redis服务器端口地址 
    # sping.redis.password 表示密码，因为密码为空，这里不设置
    jedis:
      pool:
        max-wait: 3000  # 连接池最大阻塞等待时间，单位毫秒（使用负值表示没有限制）
        min-idle: 0     # 连接池最小空闲时间
    timeout: 3000       # 连接超时时间（毫秒）

添加自定义缓存配置。自定义配置缓存管理器（RedisCacheManage）和自定义缓存方法(RedisCache)。

@Autowired
private RedisTemplate redisTemplate;

/**
 * 3.创建自定义realm
 * @return
 */
@Bean
public Realm getRealm(){
    SysUserRealm sysUserRealm = new SysUserRealm();
    // 设置缓存管理器
    sysUserRealm.setCacheManager(new RedisCacheManage(redisTemplate)); // 自定义Redis数据库缓存方法
    // 开启全局缓存
    sysUserRealm.setCachingEnabled(true);
    // 开启认证缓存并指定缓存名称
    sysUserRealm.setAuthenticationCachingEnabled(true);
    sysUserRealm.setAuthenticationCacheName("authenicationCache");
    // 开启缓存授权并指定缓存名称
    sysUserRealm.setAuthorizationCachingEnabled(true);
    sysUserRealm.setAuthorizationCacheName("authenicationCache");
    return sysUserRealm;
}

public class RedisCacheManage implements CacheManager {
    private RedisTemplate redisTemplate;

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

    @Override
    public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        return new RedisCache(s , this.redisTemplate);
    }
}

public class RedisCache<K,V> implements Cache<K,V> {
    /** 缓存名称 **/
    private String cacheName;
    private RedisTemplate redisTemplate;
    public RedisCache(String cacheName, RedisTemplate redisTemplate){
        this.cacheName = cacheName;
        this.redisTemplate = redisTemplate;
    }

    /**
     * 获取缓存
     * @param k
     * @return
     * @throws CacheException
     */
    @Override
    public V get(K k) throws CacheException {
        System.out.println("cacheName=" +this.cacheName);
        System.out.println("k=" + k.toString());
        System.out.println("res=" + this.redisTemplate);
        return (V) redisTemplate.opsForHash().get(this.cacheName,k.toString());
    }

    /**
     * 设置缓存Key
     * @param k
     * @param v
     * @return
     * @throws CacheException
     */
    @Override
    public V put(K k, V v) throws CacheException {
         redisTemplate.opsForHash().put(this.cacheName,k.toString(),v);
         return null;
    }

    /**
     * 移除缓存Key
     * @param k
     * @return
     * @throws CacheException
     */
    @Override
    public V remove(K k) throws CacheException {
        return (V)redisTemplate.opsForHash().delete(this.cacheName,k.toString());
    }

    /**
     * 清除缓存
     * @throws CacheException
     */
    @Override
    public void clear() throws CacheException {
        redisTemplate.delete(this.cacheName);
    }

    /**
     * 获取缓存的数量
     * @return
     */
    @Override
    public int size() {
        return redisTemplate.opsForHash().size(this.cacheName).intValue();
    }

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

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

 此时，我们可以运行测试方法（这里使用了测试接口）

 /**
     * 系统认证、授权测试
     * @return
     */
    @GetMapping("/test")
    public String test(){
        System.out.println("系统认证测试");
        String username = "christy";
        String password = Md5Utils.Md5PassWord("123456");
        System.out.println(password);
        try {
            Subject subject = SecurityUtils.getSubject();
            subject.login(new UsernamePasswordToken(username,password));
        }catch (UnknownAccountException e){
            System.err.println("认证失败：用户不存在");
            return  "redirect:/login";
        }catch (IncorrectCredentialsException e){
            System.err.println("认证失败：密码不正确");
            return  "redirect:/login";
        }catch (Exception e){
            System.err.println("认证失败");
            e.printStackTrace();
            // 如果认证失败仍然回到登录页面
            return  "redirect:/login";
        }
        return  "redirect:/login";
    }

调用接口后，我们发现Redis数据库存储了登录和授权的hash值。