Shiro使用redis作为缓存(解决shiro频繁访问Redis)

一个开源项目,实现了redis作为缓存缓存用户的权限和 session信息,还有两个功能没有修改,一个是用户并发登录限制,一个是用户密码错误次数.本篇中几个类也是使用的开源项目中的类,只不过是拿出来了,redis单独做的配置,方便进行优化。

原文：https://blog.csdn.net/qq_34021712/article/details/80791219 ©王赛超

有想法的文章：https://blog.csdn.net/qq_20954959/article/details/55260255

https://blog.csdn.net/why15732625998/article/details/78729254

https://www.cnblogs.com/Luke-Me/p/8941110.html

https://www.cnblogs.com/sunshine-2015/p/5686750.html

https://blog.csdn.net/qq_16055765/article/details/79298834

https://www.cnblogs.com/UncleWang001/articles/9779245.html

https://blog.csdn.net/u010514380/article/details/82185451

https://blog.csdn.net/xieliaowa9231/article/details/78995465

1.整合Redis

序列化工具SerializeUtils.java继承RedisSerializer

RedisConfig.java

RedisManager.java

2.使用Redis作为缓存需要shiro重写cache、cacheManager缓存管理器、SessionDAO

即：

RedisCache.java

RedisCacheManager.java

RedisSessionDAO.java

3.Shiro配置

ShiroConfig.java

ShiroRealm.java

KickoutSessionControlFilter.java(限制并发登录人数)

RetryLimitHashedCredentialsMatcher.java(登录错误次数限制)

ShiroSessionListener.java(session监听)

上面的类中有一些依赖类,并没有贴出来,该些类是为了解决Shiro整合Redis 频繁获取或更新 Session

整合具体流程：

1.首先是整合Redis

Redis客户端使用的是RedisTemplate,自己写了一个序列化工具SerializeUtils.java继承RedisSerializer

SerializeUtils.java

package com.springboot.test.shiro.global.utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.io.*;
/*** @author: wangsaichao* @date: 2018/6/20* @description: redis的value序列化工具*/
public class SerializeUtils implements RedisSerializer {private static Logger logger = LoggerFactory.getLogger(SerializeUtils.class);public static boolean isEmpty(byte[] data) {return (data == null || data.length == 0);}/*** 序列化* @param object* @return* @throws SerializationException*/@Overridepublic byte[] serialize(Object object) throws SerializationException {byte[] result = null;if (object == null) {return new byte[0];}try (ByteArrayOutputStream byteStream = new ByteArrayOutputStream(128);ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteStream)){if (!(object instanceof Serializable)) {throw new IllegalArgumentException(SerializeUtils.class.getSimpleName() + " requires a Serializable payload " +"but received an object of type [" + object.getClass().getName() + "]");}objectOutputStream.writeObject(object);objectOutputStream.flush();result =  byteStream.toByteArray();} catch (Exception ex) {logger.error("Failed to serialize",ex);}return result;}/*** 反序列化* @param bytes* @return* @throws SerializationException*/@Overridepublic Object deserialize(byte[] bytes) throws SerializationException {Object result = null;if (isEmpty(bytes)) {return null;}try (ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);ObjectInputStream objectInputStream = new ObjectInputStream(byteStream)){result = objectInputStream.readObject();} catch (Exception e) {logger.error("Failed to deserialize",e);}return result;}
}

RedisConfig.java

package com.springboot.test.shiro.config;
import com.springboot.test.shiro.global.utils.SerializeUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/*** @author: wangsaichao* @date: 2017/11/23* @description: redis配置*/
@Configuration
public class RedisConfig {/*** redis地址*/@Value("${spring.redis.host}")private String host;/*** redis端口号*/@Value("${spring.redis.port}")private Integer port;/*** redis密码*/@Value("${spring.redis.password}")private String password;/*** JedisPoolConfig 连接池* @return*/@Beanpublic JedisPoolConfig jedisPoolConfig(){JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();//最大空闲数jedisPoolConfig.setMaxIdle(300);//连接池的最大数据库连接数jedisPoolConfig.setMaxTotal(1000);//最大建立连接等待时间jedisPoolConfig.setMaxWaitMillis(1000);//逐出连接的最小空闲时间 默认1800000毫秒(30分钟)jedisPoolConfig.setMinEvictableIdleTimeMillis(300000);//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3jedisPoolConfig.setNumTestsPerEvictionRun(10);//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);//是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个jedisPoolConfig.setTestOnBorrow(true);//在空闲时检查有效性, 默认falsejedisPoolConfig.setTestWhileIdle(true);return jedisPoolConfig;}/*** 配置工厂* @param jedisPoolConfig* @return*/@Beanpublic JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig){JedisConnectionFactory jedisConnectionFactory=new JedisConnectionFactory();//连接池jedisConnectionFactory.setPoolConfig(jedisPoolConfig);//IP地址jedisConnectionFactory.setHostName(host);//端口号jedisConnectionFactory.setPort(port);//如果Redis设置有密码jedisConnectionFactory.setPassword(password);//客户端超时时间单位是毫秒jedisConnectionFactory.setTimeout(5000);return jedisConnectionFactory;}/*** shiro redis缓存使用的模板* 实例化 RedisTemplate 对象* @return*/@Bean("shiroRedisTemplate")public RedisTemplate shiroRedisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate redisTemplate = new RedisTemplate();redisTemplate.setKeySerializer(new StringRedisSerializer());redisTemplate.setHashKeySerializer(new StringRedisSerializer());redisTemplate.setHashValueSerializer(new SerializeUtils());redisTemplate.setValueSerializer(new SerializeUtils());//开启事务//stringRedisTemplate.setEnableTransactionSupport(true);redisTemplate.setConnectionFactory(redisConnectionFactory);return redisTemplate;}
}

RedisManager.java

package com.springboot.test.shiro.config.shiro;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**** @author wangsaichao* 基于spring和redis的redisTemplate工具类*/
public class RedisManager {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;//=============================common============================/*** 指定缓存失效时间* @param key 键* @param time 时间(秒)*/public void expire(String key,long time){redisTemplate.expire(key, time, TimeUnit.SECONDS);}/*** 判断key是否存在* @param key 键* @return true 存在 false不存在*/public Boolean hasKey(String key){return redisTemplate.hasKey(key);}/*** 删除缓存* @param key 可以传一个值 或多个*/@SuppressWarnings("unchecked")public void del(String ... key){if(key!=null&&key.length>0){if(key.length==1){redisTemplate.delete(key[0]);}else{redisTemplate.delete(CollectionUtils.arrayToList(key));}}}/*** 批量删除key* @param keys*/public void del(Collection keys){redisTemplate.delete(keys);}//============================String=============================/*** 普通缓存获取* @param key 键* @return 值*/public Object get(String key){return redisTemplate.opsForValue().get(key);}/*** 普通缓存放入* @param key 键* @param value 值*/public void set(String key,Object value) {redisTemplate.opsForValue().set(key, value);}/*** 普通缓存放入并设置时间* @param key 键* @param value 值* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期*/public void set(String key,Object value,long time){if(time>0){redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);}else{set(key, value);}}/*** 使用scan命令 查询某些前缀的key* @param key* @return*/public Set<String> scan(String key){Set<String> execute = this.redisTemplate.execute(new RedisCallback<Set<String>>() {@Overridepublic Set<String> doInRedis(RedisConnection connection) throws DataAccessException {Set<String> binaryKeys = new HashSet<>();Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder().match(key).count(1000).build());while (cursor.hasNext()) {binaryKeys.add(new String(cursor.next()));}return binaryKeys;}});return execute;}/*** 使用scan命令 查询某些前缀的key 有多少个* 用来获取当前session数量,也就是在线用户* @param key* @return*/public Long scanSize(String key){long dbSize = this.redisTemplate.execute(new RedisCallback<Long>() {@Overridepublic Long doInRedis(RedisConnection connection) throws DataAccessException {long count = 0L;Cursor<byte[]> cursor = connection.scan(ScanOptions.scanOptions().match(key).count(1000).build());while (cursor.hasNext()) {cursor.next();count++;}return count;}});return dbSize;}
}

2.使用Redis作为缓存需要shiro重写cache、cacheManager、SessionDAO

RedisCache.java

package com.springboot.test.shiro.config.shiro;
import com.springboot.test.shiro.global.exceptions.PrincipalIdNullException;
import com.springboot.test.shiro.global.exceptions.PrincipalInstanceException;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
/*** @author: wangsaichao* @date: 2018/6/22* @description: 参考 shiro-redis 开源项目 Git地址 https://github.com/alexxiyang/shiro-redis*/
public class RedisCache<K, V> implements Cache<K, V> {private static Logger logger = LoggerFactory.getLogger(RedisCache.class);private RedisManager redisManager;private String keyPrefix = "";private int expire = 0;private String principalIdFieldName = RedisCacheManager.DEFAULT_PRINCIPAL_ID_FIELD_NAME;/*** Construction* @param redisManager*/public RedisCache(RedisManager redisManager, String prefix, int expire, String principalIdFieldName) {if (redisManager == null) {throw new IllegalArgumentException("redisManager cannot be null.");}this.redisManager = redisManager;if (prefix != null && !"".equals(prefix)) {this.keyPrefix = prefix;}if (expire != -1) {this.expire = expire;}if (principalIdFieldName != null && !"".equals(principalIdFieldName)) {this.principalIdFieldName = principalIdFieldName;}}@Overridepublic V get(K key) throws CacheException {logger.debug("get key [{}]",key);if (key == null) {return null;}try {String redisCacheKey = getRedisCacheKey(key);Object rawValue = redisManager.get(redisCacheKey);if (rawValue == null) {return null;}V value = (V) rawValue;return value;} catch (Exception e) {throw new CacheException(e);}}@Overridepublic V put(K key, V value) throws CacheException {logger.debug("put key [{}]",key);if (key == null) {logger.warn("Saving a null key is meaningless, return value directly without call Redis.");return value;}try {String redisCacheKey = getRedisCacheKey(key);redisManager.set(redisCacheKey, value != null ? value : null, expire);return value;} catch (Exception e) {throw new CacheException(e);}}@Overridepublic V remove(K key) throws CacheException {logger.debug("remove key [{}]",key);if (key == null) {return null;}try {String redisCacheKey = getRedisCacheKey(key);Object rawValue = redisManager.get(redisCacheKey);V previous = (V) rawValue;redisManager.del(redisCacheKey);return previous;} catch (Exception e) {throw new CacheException(e);}}private String getRedisCacheKey(K key) {if (key == null) {return null;}return this.keyPrefix + getStringRedisKey(key);}private String getStringRedisKey(K key) {String redisKey;if (key instanceof PrincipalCollection) {redisKey = getRedisKeyFromPrincipalIdField((PrincipalCollection) key);} else {redisKey = key.toString();}return redisKey;}private String getRedisKeyFromPrincipalIdField(PrincipalCollection key) {String redisKey;Object principalObject = key.getPrimaryPrincipal();Method pincipalIdGetter = null;Method[] methods = principalObject.getClass().getDeclaredMethods();for (Method m:methods) {if (RedisCacheManager.DEFAULT_PRINCIPAL_ID_FIELD_NAME.equals(this.principalIdFieldName)&& ("getAuthCacheKey".equals(m.getName()) || "getId".equals(m.getName()))) {pincipalIdGetter = m;break;}if (m.getName().equals("get" + this.principalIdFieldName.substring(0, 1).toUpperCase() + this.principalIdFieldName.substring(1))) {pincipalIdGetter = m;break;}}if (pincipalIdGetter == null) {throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName);}try {Object idObj = pincipalIdGetter.invoke(principalObject);if (idObj == null) {throw new PrincipalIdNullException(principalObject.getClass(), this.principalIdFieldName);}redisKey = idObj.toString();} catch (IllegalAccessException e) {throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName, e);} catch (InvocationTargetException e) {throw new PrincipalInstanceException(principalObject.getClass(), this.principalIdFieldName, e);}return redisKey;}@Overridepublic void clear() throws CacheException {logger.debug("clear cache");Set<String> keys = null;try {keys = redisManager.scan(this.keyPrefix + "*");} catch (Exception e) {logger.error("get keys error", e);}if (keys == null || keys.size() == 0) {return;}for (String key: keys) {redisManager.del(key);}}@Overridepublic int size() {Long longSize = 0L;try {longSize = new Long(redisManager.scanSize(this.keyPrefix + "*"));} catch (Exception e) {logger.error("get keys error", e);}return longSize.intValue();}@SuppressWarnings("unchecked")@Overridepublic Set<K> keys() {Set<String> keys = null;try {keys = redisManager.scan(this.keyPrefix + "*");} catch (Exception e) {logger.error("get keys error", e);return Collections.emptySet();}if (CollectionUtils.isEmpty(keys)) {return Collections.emptySet();}Set<K> convertedKeys = new HashSet<K>();for (String key:keys) {try {convertedKeys.add((K) key);} catch (Exception e) {logger.error("deserialize keys error", e);}}return convertedKeys;}@Overridepublic Collection<V> values() {Set<String> keys = null;try {keys = redisManager.scan(this.keyPrefix + "*");} catch (Exception e) {logger.error("get values error", e);return Collections.emptySet();}if (CollectionUtils.isEmpty(keys)) {return Collections.emptySet();}List<V> values = new ArrayList<V>(keys.size());for (String key : keys) {V value = null;try {value = (V) redisManager.get(key);} catch (Exception e) {logger.error("deserialize values= error", e);}if (value != null) {values.add(value);}}return Collections.unmodifiableList(values);}public String getKeyPrefix() {return keyPrefix;}public void setKeyPrefix(String keyPrefix) {this.keyPrefix = keyPrefix;}public String getPrincipalIdFieldName() {return principalIdFieldName;}public void setPrincipalIdFieldName(String principalIdFieldName) {this.principalIdFieldName = principalIdFieldName;}
}

getRedisKeyFromPrincipalIdField()是获取缓存的用户身份信息和用户权限信息。里面有一个属性principalIdFieldName 在RedisCacheManager也有这个属性,设置其中一个就可以.是为了给缓存用户身份和权限信息在Redis中的key唯一,登录用户名可能是username 或者 phoneNum 或者是Email中的一个,如我的User实体类中有一个 usernane字段,也是登录时候使用的用户名,在redis中缓存的权限信息key 如下, 这个admin 就是通过getUsername获得的。

读取用户权限信息时,还用到两个异常类，如下：

PrincipalInstanceException.java

package com.springboot.test.shiro.global.exceptions;
/*** @author: wangsaichao* @date: 2018/6/21* @description:*/
public class PrincipalInstanceException extends RuntimeException  {private static final String MESSAGE = "We need a field to identify this Cache Object in Redis. "+ "So you need to defined an id field which you can get unique id to identify this principal. "+ "For example, if you use UserInfo as Principal class, the id field maybe userId, userName, email, etc. "+ "For example, getUserId(), getUserName(), getEmail(), etc.\n"+ "Default value is authCacheKey or id, that means your principal object has a method called \"getAuthCacheKey()\" or \"getId()\"";public PrincipalInstanceException(Class clazz, String idMethodName) {super(clazz + " must has getter for field: " +  idMethodName + "\n" + MESSAGE);}public PrincipalInstanceException(Class clazz, String idMethodName, Exception e) {super(clazz + " must has getter for field: " +  idMethodName + "\n" + MESSAGE, e);}
}

PrincipalIdNullException.java

package com.springboot.test.shiro.global.exceptions;
/*** @author: wangsaichao* @date: 2018/6/21* @description:*/
public class PrincipalIdNullException extends RuntimeException  {private static final String MESSAGE = "Principal Id shouldn't be null!";public PrincipalIdNullException(Class clazz, String idMethodName) {super(clazz + " id field: " +  idMethodName + ", value is null\n" + MESSAGE);}
}