[Shiro入门]（一）使用Redis作为缓存管理器

简述

Shiro提供了类似Spring的Cache抽象，即Shiro本身不实现Cache，但是对Cache进行了又抽象，方便更换不同的底层Cache实现，而Shiro官方提供了对于Ehcache缓存的支持，并提供了shiro-ehcache.jar的包。但是我们想要用Redis来作为缓存管理器，Ehcache和Redis的优劣可以去自行百度。后面我也会通过查资料总结一下的。

Shiro提供的接口

1. Shiro提供的Cache接口：

public interface Cache {  
    //根据Key获取缓存中的值  
    public V get(K key) throws CacheException;  
    //往缓存中放入key-value，返回缓存中之前的值  
    public V put(K key, V value) throws CacheException;   
    //移除缓存中key对应的值，返回该值  
    public V remove(K key) throws CacheException;  
    //清空整个缓存  
    public void clear() throws CacheException;  
    //返回缓存大小  
    public int size();  
    //获取缓存中所有的key  
    public Set keys();  
    //获取缓存中所有的value  
    public Collection values();  
}

1. Shiro提供的CacheManager接口

public interface CacheManager {  
    //根据缓存名字获取一个Cache  
    public  Cache getCache(String name) throws CacheException;  
}  

1. Shiro提供了CacheManagerAware用户注入CacheManager

public interface CacheManagerAware {  
    //注入CacheManager  
    void setCacheManager(CacheManager cacheManager);  
}  

Shiro内部响应的组件（DefaultSecurityManager）会自动检测响应的对象（如Realm）是否实现了CacheManagerAware并自动注入响应的CacheManager。

配置缓存管理器

我们要使用Redis作为缓存管理器，那么我们就需要实现这些接口，但是前提是我们要在Spring-Shiro.xml中配置缓存管理器。

    
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="sessionManager" ref="sessionManager"/>
        <property name="cacheManager" ref="customCacheManager"/>
        <property name="realms">
            <list>
                <ref bean="shiroRealm"/>
            list>
        property>
    bean>

    
    <bean id="shiroRealm" class="com.why.authority.realms.ShiroRealm">
        
        <property name="credentialsMatcher" ref="credentialsMatcher"/>
        
        <property name="cachingEnabled" value="true"/>
        
        <property name="authenticationCachingEnabled" value="true"/>
        
        <property name="authorizationCachingEnabled" value="true"/>
    bean>

    
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        
        <property name="sessionIdUrlRewritingEnabled" value="false" />
        
        <property name="globalSessionTimeout" value="1800000"/>
        <property name="deleteInvalidSessions" value="true"/>
        <property name="sessionValidationSchedulerEnabled" value="true"/>
        <property name="sessionIdCookieEnabled" value="true"/>
    bean>

    
    
    <bean id="customCacheManager" class="com.why.authority.cache.CustomCacheManager"/>

创建RedisCache实现Cache接口

package com.why.authority.cache;

import com.why.utils.jedis.JedisClientSingle;
import com.why.utils.serializable.ByteSourceUtils;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import redis.clients.jedis.Jedis;

import java.io.Serializable;
import java.util.*;

/**
 * @author: 王洪玉
 * @decsription: 缓存管理器
 * @create: 2017/12/5 21:18
 * @modified By:
 */
public class RedisCache<K,V> implements Cache<K,V> {

    public String getKeyPrefix() {
        return keyPrefix;
    }

    public void setKeyPrefix(String keyPrefix) {
        this.keyPrefix = keyPrefix;
    }

    private String keyPrefix = "shiro_redis_session:";
    /**
     * 获得byte[]型的key
     * @param key
     * @return
     */
    private byte[] getByteKey(Object key){
        if(key instanceof String){
            String preKey = this.keyPrefix + key;
            return preKey.getBytes();
        }else{
            return ByteSourceUtils.serialize((Serializable) key);
        }
    }


    @Override
    public Object get(Object key) throws CacheException {

        byte[] bytes = getByteKey(key);
        byte[] value = JedisClientSingle.getJedis().get(bytes);
        if(value == null){
            return null;
        }
        return ByteSourceUtils.deserialize(value);
    }

    /**
     * 将shiro的缓存保存到redis中
     */
    @Override
    public Object put(Object key, Object value) throws CacheException {

        Jedis jedis = JedisClientSingle.getJedis();

        jedis.set(getByteKey(key), ByteSourceUtils.serialize((Serializable)value));
        byte[] bytes = jedis.get(getByteKey(key));
        Object object = ByteSourceUtils.deserialize(bytes);

        return object;

    }

    @Override
    public Object remove(Object key) throws CacheException {
        Jedis jedis = JedisClientSingle.getJedis();

        byte[] bytes = jedis.get(getByteKey(key));

        jedis.del(getByteKey(key));

        return ByteSourceUtils.deserialize(bytes);
    }

    /**
     * 清空所有缓存
     */
    @Override
    public void clear() throws CacheException {
        JedisClientSingle.getJedis().flushDB();
    }

    /**
     * 缓存的个数
     */
    @Override
    public int size() {
        Long size = JedisClientSingle.getJedis().dbSize();
        return size.intValue();
    }

    /**
     * 获取所有的key
     */
    @Override
    public Set keys() {
        Set keys = JedisClientSingle.getJedis().keys(new String("*").getBytes());
        Set