shiro配置redis做缓存并且配置session共享实现集群

shiro和redis的maven依赖

	  
      
        org.apache.shiro  
        shiro-core  
        1.3.2  
    
      
        org.apache.shiro  
        shiro-web  
        1.3.2  
      
      
        org.apache.shiro  
        shiro-spring  
        1.3.2  
    
    
	  org.apache.shiro
	  shiro-ehcache
	  1.3.2
	

	
	
        redis.clients
        jedis
        2.9.0
    
    
      
        org.springframework.data  
        spring-data-redis  
        1.8.7.RELEASE  
    

本配置的前提是已经配置好redis，并且使用spring的redisTemplate进行配置

1、shiro的完整xml配置

	
	
	
	    
	    
	    
	    
	    
	    
	    
	    
	    
	        
	            /web/page/login.do = anon 
	            /app/** = anon
	            /** = anon 
	        
	    
	
	
	
	
		
		
		
		
		
		
	
	
	
	
		
        
        
        
        
        
        
        
	
	
	
    
        
        
        
        
        
        
        
        
        
        
        
        
    
    
    
    
    
    
    
        
        
        
        
    

    
    
    
	
	
    
        
        
        
        
    
	
	
	
    
    

    
        
    

    
        
    
    
        
            
                
                
                    redirect:/web/page/login.do
                
                
                
                    redirect:/web/page/unauthorized.do
                
            
        
        
    

主要是注意session管理和缓存管理的配置

主要是上面这几个配置，自定义了shiro的缓存管理myCacheManager和sessionDAO管理redisSessionDao

2、redis的完整xml配置

redis的参数

#redis config
redis.host=127.0.0.1
redis.port=6379
redis.pass=123456
redis.maxTotal=2000
redis.maxIdle=50
redis.maxWaitMillis=15000
redis.lifo=true
redis.blockWhenExhausted=true
redis.testOnBorrow=false
redis.testOnReturn=false
redis.testWhileIdle=false
redis.timeBetweenEvictionRunsMillis=30000

3、相关shiro自定义类

MyCacheManager实现shiro的CacheManager缓存管理接口

import java.io.Serializable;

import javax.annotation.Resource;

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;

/**
 * 
 * @author Administrator
 *
 */
public class MyCacheManager implements CacheManager {

	@Resource
    private RedisTemplate redisTemplate;

    @Override
    public  Cache getCache(String name) throws CacheException {
        return new RedisCache(redisTemplate);
    }
}

RedisCache实现shiro的Cache缓存接口

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

import constant.RedisConstant;
import redis.RedisUtils;
import redis.clients.jedis.Jedis;
import utils.SerializeUtils;

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

import javax.annotation.Resource;

/**
 * 用redis操作实现shiro缓存接口
 * @author Administrator
 *
 * @param 
 * @param 
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class RedisCache implements Cache {

	private RedisTemplate redisTemplate; 
	
	private String keyPrefix = RedisConstant.SHIRO_REDIS_SESSION_PRE;
	
	public RedisCache(RedisTemplate redisTemplate) {
		super();
		// TODO Auto-generated constructor stub
		//构造函数传递redisTemplate过来
		this.redisTemplate = redisTemplate;
	}
	
    public String getKeyPrefix() {
        return keyPrefix;
    }

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

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

	private RedisConnection getRedisConnect() {
    	return redisTemplate.getConnectionFactory().getConnection();
    }

    @Override
    public Object get(Object key) throws CacheException {
        byte[] bytes = getByteKey(key);
        byte[] value = getRedisConnect().get(bytes);
        if(value == null){
            return null;
        }
        return SerializeUtils.deserialize(value);
    }

    /**
     * 将shiro的缓存保存到redis中
     */
    @Override
    public Object put(Object key, Object value) throws CacheException {
    	RedisConnection redisConnection = getRedisConnect();
    	redisConnection.set(getByteKey(key), SerializeUtils.serialize((Serializable)value));
        byte[] bytes = redisConnection.get(getByteKey(key));
        Object object = SerializeUtils.deserialize(bytes);

        return object;

    }

    @Override
    public Object remove(Object key) throws CacheException {
    	RedisConnection redisConnection = getRedisConnect();

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

        redisConnection.del(getByteKey(key));

        return SerializeUtils.deserialize(bytes);
    }

    /**
     * 清空所有缓存
     */
    @Override
    public void clear() throws CacheException {
    	RedisConnection redisConnection = getRedisConnect();
    	redisConnection.flushDb();
    }

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

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