SpringBoot2 (xii) when Shiro met RedisCache

ShiroCache focus on configuration SecurityManager, only the following two key configuration, SessionManager can all be default, no design,

Focus on CacheManager, CacheManager CacheManager interface and the need to implement Cache interface.

securityManager.setSessionManager(SessionManager sessionManager)；
securityManager.setCacheManager(CacheManager cacheManager) ；

SecurityManager related AuthorizingRealm, the configuration found AuthorizingRealm implementation class, you can find SecurityManager 

  /**
   * 安全管理器
   */
  @Bean
  public SecurityManager securityManager(RedisTemplate<String, Object> redisTemplate) {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setCacheManager(new ShiroRedisCacheManager(redisTemplate));
    securityManager.setRealm(new ShiroRealm());
    securityManager.setSessionManager(sessionManager());
    return securityManager;
  }

  /**
   * session 管理对象
   */
  private DefaultWebSessionManager sessionManager() {
    DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    sessionManager.setGlobalSessionTimeout(1800000L);
    sessionManager.setSessionDAO(new EnterpriseCacheSessionDAO());
    return sessionManager;
  }

RedisTemplate

Shiro is EhCache default cache, so the code focused on the sequence of the JDK, so when using Redis necessary to realize a serialized using JDK RedisTemplate.
Using JSON serialization can, but need additional design, there is not eventful.

 /**
   * RedisTemplate配置--Shiro专属
   */
  @Bean
  public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    RedisSerializer<String> stringSerializer = new StringRedisSerializer();
    JdkSerializationRedisSerializer fastJsonRedisSerializer = new JdkSerializationRedisSerializer();

    redisTemplate.setKeySerializer(stringSerializer);
    redisTemplate.setValueSerializer(fastJsonRedisSerializer);

    redisTemplate.setHashKeySerializer(stringSerializer);
    redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);

    redisTemplate.setConnectionFactory(lettuceConnectionFactory);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
  }

ShiroRedisCacheManager 

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;

/**
 * @author Mr.css
 * @date 2020/1/3
 */
public class ShiroRedisCacheManager extends AbstractCacheManager {

  private RedisTemplate<String,Object> redisTemplate;

  public ShiroRedisCacheManager(RedisTemplate<String,Object> redisTemplate){
    this.redisTemplate = redisTemplate;
  }

  @Override
  protected Cache createCache(String name) throws CacheException {
    return new ShiroRedisCache(redisTemplate,name);
  }
}

ShiroRedisCache 

Such cache interface has been exposed, as to how to deal with cache, it all depends on personal preference

Import org.apache.shiro.cache.Cache;
 Import org.apache.shiro.cache.CacheException;
 Import org.apache.shiro.session.mgt.ValidatingSession;
 Import org.springframework.data.redis.core.RedisTemplate; 

Import Java * .util. ; 

/ ** 
 * @author Mr.css 
 * @date 2020/1/3 
 * / 
public  class ShiroRedisCache the implements the Cache <String, ValidatingSession> {
   Private RedisTemplate <String, Object> redisTemplate;
   / ** 
   * prefix, Shiro is used to identify which data prefix is too long, it does affect the search efficiency can be optimized 
   * / 
  Private String prefix;

  private String getKey(String key){
    return prefix + key;
  }

  ShiroRedisCache(RedisTemplate<String,Object> redisTemplate, String prefix) {
    this.redisTemplate = redisTemplate;
    this.prefix = prefix;
  }

  @Override
  public ValidatingSession get(String key) throws CacheException {
    if (key == null) {
      return null;
    }
    return (ValidatingSession) redisTemplate.opsForValue().get(this.getKey(key));
  }

  @Override
  public ValidatingSession put(String key, ValidatingSession value) throws CacheException {
    if (key == null || value == null) {
      return null;
    }
    redisTemplate.opsForValue().set(this.getKey(key), value);
    return value;
  }

  @Override
  public ValidatingSession remove(String key) throws CacheException {
    if (key == null) {
      return null;
    }
    key = this.getKey(key);
    ValidatingSession value = (ValidatingSession) redisTemplate.opsForValue().get(key);
    redisTemplate.delete(key);
    return value;
  }

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

  @Override
  public int size() {
    return this.keys().size();
  }

  @Override
  public Set<String> keys() {
    return redisTemplate.keys(prefix + "*");
  }

  @Override
  public Collection<ValidatingSession> values() {
    Set<String> keys = keys();
    List<ValidatingSession> values = new ArrayList<>(keys.size());
    for (String k : keys) {
      values.add((ValidatingSession)redisTemplate.opsForValue().get(k));
    }
    return values;
  }
}