Shiro自定义缓存，扩展Shiro缓存模块，只需要配置缓存即可实现Session共享

Shiro自定义缓存

之前在做Shiro集成的时候，辗转各个论坛，对于ehcache和redis集成太过繁琐，想尝试着将Shiro的缓存抽象出来，在不改变Shiro的前提下，达到缓存的可配置方案，那样对于项目而言可以更好的实现集群的部署。
于是就衍生了如下的设计：
一、设计方案
1.Shiro配置文件的修改
我们还是来介绍一下Shiro的自定义缓存吧，当有这个想法的时候，翻阅了各个地方的文档和demo最后发现Shiro是支持自定义缓存的，但需要集成AbstractCacheManager来实现

Shiro自定义缓存只需要在Shiro的配置文件中替换原有的cacheManager，
我便尝试着使用自己新建的cacheManager

<bean id="cacheManager" class="com.cn.contiy.system.shiro.entity.SMCacheManager" />

SpringBoot同理，修改代码而已。

2.自行实现的缓存类
当我们集成AbstractCacheManager后，我们会发现在AbstractCacheManager有一个抽象方法需要实现

 protected abstract Cache createCache(String s)
        throws CacheException;

显而易见，这个方法是Shiro的CacheManager用来创建缓存，所以，我们就需要在此处进行集成，这个先暂时不实现；
这个创建缓存的方法使用了一个返回值Cache，观察了一下是基于org.apache.shiro.cache.Cache接口的，所以，重点就是在此处怎样合理的使用org.apache.shiro.cache.Cache接口，以下便是心路历程

a.实现org.apache.shiro.cache.Cache接口
b.实现类实现createCache，并返回实现了org.apache.shiro.cache.Cache接口的实现类
c.在org.apache.shiro.cache.Cache接口的实现类中，封装缓存接口
d.分别使用Redis和Ehcache实现缓存接口
e.使用工厂类获取缓存
f.在项目启动时确定项目使用的缓存方式

SO，手术开始：
（1）创建通用缓存接口

public interface Cacher {
	public void set(String key, Object value);
	public Object get(String key);
	public void delete(String key);
	public Set<String> keys(String string);
	public Set<?> getAllValue(String keyPrefix);
	public Long dbSize();
}

接口的方法我就不描述了，一是因为懒，二是因为基本看英文能看懂是个什么玩意儿
（2）Cache工厂，切换缓存

public class CacherFactory {
	/** @desc 缓存工具 */
	public static Cacher cacher;

	@SuppressWarnings("static-access")
	public static void setAdpt(Object cacherAdpt) {
		cacher = (Cacher) cacherAdpt;
	}

}

定义了缓存工厂后，使用缓存就很容易了，只需要CacherFactory.cacher即可
（3）Redis缓存实现类

@Service("redisCacher")
@SuppressWarnings({ "unchecked", "rawtypes" })
public class RedisCacher implements Cacher {

	@Resource
	private org.springframework.data.redis.core.RedisTemplate redisTemplate;

	public void set(String key, Object value) {
		redisTemplate.opsForValue().set(key, value);
		// BoundValueOperations的理解对保存的值做一些细微的操作
		// BoundValueOperations boundValueOperations =
		// redisTemplate.boundValueOps(key);
	}

	public Object get(String key) {
		return redisTemplate.opsForValue().get(key);
	}

	
	public void delete(String key) {
		redisTemplate.delete(key);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.cn.contiy.system.cache.Cacher#keys(java.lang.String)
	 */
	@Override
	public Set<String> keys(String key) {
		return redisTemplate.keys(key + "*");
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.cn.contiy.system.cache.Cacher#getAllValue(java.lang.String)
	 */
	@Override
	public Set<?> getAllValue(String keyPrefix) {
		Set<Object> list = new HashSet<Object>();
		ValueOperations v = redisTemplate.opsForValue();
		Set<String> keys = this.keys(keyPrefix);
		for (String string : keys) {
			list.add(v.get(string));
		}
		return list;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.cn.contiy.system.cache.Cacher#dbSize()
	 */
	@Override
	public Long dbSize() {
		return redisTemplate.getConnectionFactory().getConnection().dbSize();
	}

}

RedisCacher如上文所言，实现接口的方法，其余缓存也是一样
（4）实现org.apache.shiro.cache.Cache接口

@Service("shiroCache")
public class ShiroCache<K, V> implements Cache<K, V> {
	/**
	*这个是给Shiro的缓存Key进行分组标识，标识在缓存中以这个Key开头的都是Shiro的缓存
	*/
	private static final String KEY_PREFIX = "shiro_session:";

	/*
	 * 这个clear方法没做好，应该在cacher接口中定义，由缓存的实现类去实现
	 * 
	 * @see org.apache.shiro.cache.Cache#clear()
	 */
	@Override
	public void clear() throws CacheException {
		Set<String> keys = CacherFactory.cacher.keys(KEY_PREFIX);
		for (String string : keys) {
			CacherFactory.cacher.delete(string);
		}
	}

	private String getkey(String key) {
		return KEY_PREFIX + key;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.shiro.cache.Cache#get(java.lang.Object)
	 */
	@SuppressWarnings("unchecked")
	@Override
	public V get(K arg0) throws CacheException {
		return (V) CacherFactory.cacher.get(getkey(arg0.toString()));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.shiro.cache.Cache#keys()
	 */
	@SuppressWarnings("unchecked")
	@Override
	public Set<K> keys() {
		return (Set<K>) CacherFactory.cacher.keys(KEY_PREFIX);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.shiro.cache.Cache#put(java.lang.Object, java.lang.Object)
	 */
	@Override
	public V put(K arg0, V arg1) throws CacheException {
		CacherFactory.cacher.set(getkey(arg0.toString()), arg1);
		return arg1;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.shiro.cache.Cache#remove(java.lang.Object)
	 */
	@Override
	public V remove(K arg0) throws CacheException {
		V previous = get(arg0);
		CacherFactory.cacher.delete(getkey(arg0.toString()));
		return previous;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.shiro.cache.Cache#size()
	 */
	@Override
	public int size() {
		Long longSize = CacherFactory.cacher.dbSize();
		return longSize.intValue();
	}

	/*
	 * 因为缓存中只要Shiro的key，免不了这一步
	 * 
	 * @see org.apache.shiro.cache.Cache#values()
	 */
	@SuppressWarnings("unchecked")
	@Override
	public Collection<V> values() {
		Collection<V> v = new HashSet<>();
		Set<String> keys = CacherFactory.cacher.keys(KEY_PREFIX);
		for (String string : keys) {
			if (CacherFactory.cacher.get(string) != null) {
				v.add((V) CacherFactory.cacher.get(string));
			}
		}
		return v;
	}

}

（5）在自定义的CacheManager中加入自定义的Cache

public class SMCacheManager extends AbstractCacheManager {

	@SuppressWarnings("unused")
	private static final Logger logger = LoggerFactory.getLogger(SMCacheManager.class);

	@SuppressWarnings("rawtypes")
	@Resource
	private Cache shiroCache;

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.apache.shiro.cache.AbstractCacheManager#createCache(java.lang.String)
	 */
	@SuppressWarnings("rawtypes")
	@Override
	protected Cache createCache(String s) throws CacheException {
		//我这里是用Spring注入的，所以就直接返回了
		return shiroCache;
	}
}

（6）启动时设置缓存方式

public void initCache() {
		switchRedis = "OFF";
		try {
			switchRedis = systemSettingBiz.getSysDetail("system.redis.switch");
			redisTemplate.opsForValue().get("");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			log.error("------------------------------redis缓存关闭,切换到ehCacher----------------------");
			switchRedis = "OFF";
		}
		if (switchRedis.equalsIgnoreCase("OFF")) {
			log.info("----------------------开启ehCacher------------------------------");
			CacherFactory.setAdpt(ehCacher);
		} else {
			log.info("----------------------开启redisCacher----------------------------");
			CacherFactory.setAdpt(redisCacher);
		}
	}

（7）修改Shiro配置文件

<bean id="cacheManager" class="com.cn.contiy.system.shiro.entity.SMCacheManager" />

至此，完成，代码写得比较渣，请大佬莫怪，仅仅提供一个想法
这种方式的有点就是Shiro不需要在乎你使用的是什么缓存，可以说将Shiro的缓存已经抽象出来了，可以这么说，就算，你的Shiro使用缓存的方式，使用数据库的方式，也只需要实现Cacher接口，在应用启动时设置开关切换，即可实现Shiro的缓存，而自定义缓存更多的为了将Session统一，对于分布式的系统，个人觉得还是非常重要的。

PS：处女文，请大佬多多指点，谢谢！（手下留情）