shiro 集成spring 使用 redis作為緩存 學習記錄（六）

1、在applicationContext-redis.xml配置文件中增加如下： 申明一個cacheManager對象 用來注入到  shiro的   securityManager 屬性  cacheManager 中

<!--spring rediscache-->
    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager"
          c:redisOperations-ref="redisTemplate">
        <!--         默認緩存10分鍾 -->
        <property name="defaultExpiration" value="10"/>
        <!-- key:prefix -->
        <property name="usePrefix" value="true"/>
        <!--         cacheName 緩存超時配置，半小時，一小時，一天 -->
        <property name="expires">
            <map key-type="java.lang.String" value-type="java.lang.Long">
                <entry key="halfHour" value="1800"/>
                <entry key="hour" value="3600"/>
                <entry key="oneDay" value="86400"/>
                <entry key="itzixiCaptcha" value="500"/>
                <!--                 shiro cache keys -->
                <entry key="authenticationCache" value="1800"/><!-- 用戶每次操作后會要等緩存過期后會重新再取 -->
                <entry key="authorizationCache" value="1800"/><!-- 用戶每次操作后會要等緩存過期后會重新再取 -->
                <entry key="activeSessionCache" value="1800"/><!-- 用戶session每次操作后會重置時間 -->
            </map>
        </property>
    </bean>

    <!-- cache注解，項目中如果還存在shiro的ehcache的話，那么本文件和spring-ehcache.xml中的只能使用一個 -->
    <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/>

2、編寫這兩個 ShiroSpringCache.java

import java.util.Collection;
import java.util.Collections;
import java.util.Set;

import org.apache.shiro.cache.CacheException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.Cache;
import org.springframework.cache.Cache.ValueWrapper;

/**
 * 
 * @Title: ShiroSpringCache.java
 * @Description: 實現spring cache作為shiro的緩存
 * @date 2017年10月14日 下午12:08:56
 * @version V1.0
 */
@SuppressWarnings("unchecked")
public class ShiroSpringCache<K, V> implements org.apache.shiro.cache.Cache<K, V> {
    final static Logger logger = LoggerFactory.getLogger(ShiroSpringCache.class);
    
    private final org.springframework.cache.Cache cache;
    
    public ShiroSpringCache(Cache cache) {
        if (cache == null) {
            throw new IllegalArgumentException("Cache argument cannot be null.");
        }
        this.cache = cache;
    }

    @Override
    public V get(K key) throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Getting object from cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        ValueWrapper valueWrapper = cache.get(key);
        if (valueWrapper == null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Element for [" + key + "] is null.");
            }
            return null;
        }
        return (V) valueWrapper.get();
    }

    @Override
    public V put(K key, V value) throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Putting object in cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        V previous = get(key);
        cache.put(key, value);
        return previous;
    }

    @Override
    public V remove(K key) throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Removing object from cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        V previous = get(key);
        cache.evict(key);
        return previous;
    }

    @Override
    public void clear() throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Clearing all objects from cache [" + this.cache.getName() + "]");
        }
        cache.clear();
    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public Set<K> keys() {
        return Collections.emptySet();
    }

    @Override
    public Collection<V> values() {
        return Collections.emptySet();
    }

    @Override
    public String toString() {
        return "ShiroSpringCache [" + this.cache.getName() + "]";
    }
}

ShiroSpringCacheManager.java

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.util.Destroyable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * @Title: ShiroSpringCacheManager.java
 * @Description: 實現shiro的cacheManager
 * @date 2017年10月14日 下午12:09:49
 * @version V1.0
 */
public class ShiroSpringCacheManager implements CacheManager, Destroyable {
    
    final static Logger logger = LoggerFactory.getLogger(ShiroSpringCacheManager.class);
    
    private org.springframework.cache.CacheManager cacheManager;
    
    public org.springframework.cache.CacheManager getCacheManager() {
        return cacheManager;
    }

    public void setCacheManager(org.springframework.cache.CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Acquiring ShiroSpringCache instance named [" + name + "]");
        }
        org.springframework.cache.Cache cache = cacheManager.getCache(name);
        return new ShiroSpringCache<K, V>(cache);
    }

    @Override
    public void destroy() throws Exception {
        cacheManager = null;
    }

}

3、在applicationContext-shiro.xml配置文件中增加：

<!-- 用戶授權信息Cache, 采用spring-cache,  -->
    <bean id="shiroRedisCacheManager" class="com.itzixi.web.shiro.ShiroSpringCacheManager">
        <property name="cacheManager" ref="cacheManager"/>
    </bean>

4、修改shiro安全管理器的使用對象如：

5、使用redis作為shiro的緩存注意，因為shiro的緩存是一個實體的對象，所有在序列化的時候必須使用jdk序列化

 6、同時需要配置自定義Realm中開啟緩存的配置，認證緩存、權限緩存、seesion緩存

7、在自定義Realm中 將配置的shiroReadisCacheManager對象作為參數傳入到構造方法中注入進來