springboot使用shiro框架基于redis实现session共享

什么是Apache Shiro？

Apache Shiro是一个功能强大且易于使用的Java安全框架，为开发人员提供了一个直观而全面的解决方案，用于身份验证、授权、加密和会话管理。
由于本篇主要解决shiro管理下session共享问题,shiro基本功能和用法就不赘述了.

Shiro的架构

shiro架构图

session共享主要自定义 session Manager ,session DAO , cacheManager 和 cache来实现

sessionManager : shiro 会话的管理器,网络会话使用WebSessionManager
sessionDao: 存取会话的DAO层实现
cacheManager: 缓存管理器
cache: 负责缓存存取的DAO层实现

自定义类的意义

sessionManager和sessionDao

由于sessionManager负责管理sessionDao ,想要自定义 sessionDao 必须先自定义 sessionManager
sessionDao是实现session共享的核心,通过自定义该类,来实现用redis管理session

cacheManager和cahe

cacheManager和cahe和上面两者的关系基本相同,前者是管理器,后者是dao层实现;
shiro框架对身份认证和权限认证有缓存功能,在配置realm时可以设置是否开启此功能(realm主要就是负责身份认证和权限认证的工作),由于realm的功能原因,基本都要去数据库或网络IO,所有使用缓存是十分有用的,在这里我们也用redis进行缓存的管理;

结合配置分析

话不多说上配置文件

我们使用spirng注解方式来配置shiro

SecurityManager

往大的将融合redis就是改造SecurityManager,通过setCacheManager()和setSessionManager()方法分别设置缓存管理器和会话管理器,配置如下:

    @Bean("securityManager")
    public DefaultWebSecurityManager getManager() {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(getRealm());
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        manager.setSubjectDAO(subjectDAO);
        //以上部分未做改动,重点在下面两方法

        //redis缓存和session共享
        if("y".equals(redis)){
            // 设置缓存,该缓存使用不使用,由realm的配置决定
            System.out.println("使用redis进行session共享");
            manager.setCacheManager(getRedisCacheManager());
            manager.setSessionManager(getDefaultWebSessionManager());
        }
        return manager;
    }

将该类设置进ShiroFilterFactoryBean中

会话管理器
SessionManager:

    @Bean(name = "sessionManager")
    public DefaultWebSessionManager getDefaultWebSessionManager() {
        //自定义sessionManager为了解决浏览器访问时网址后面添加;SESSIONID=xxxx的问题
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager(){
            //参考https://blog.csdn.net/yyf314922957/article/details/51038322
            @Override
            protected void onStart(Session session, SessionContext context) {
                super.onStart(session, context);
                ServletRequest request = WebUtils.getRequest(context);
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
            }
        };
        sessionManager.setDeleteInvalidSessions(true);
        sessionManager.setSessionDAO(getRedisSessionDao());
        sessionManager.setSessionIdCookie(getSimpleCookie());
        //相隔多久检查一次session的有效性
        sessionManager.setSessionValidationInterval(validate);
        //session 有效期
        sessionManager.setGlobalSessionTimeout(timeout);
        return sessionManager;
    }

SessionDao

    //配置基于redis的SessionDao
    @Bean("redisSessionDao")
    public MyRedisSessionDao getRedisSessionDao() {
        MyRedisSessionDao sessionDAO = new MyRedisSessionDao();
        return sessionDAO;
    }

SimpleCookie
可以注意到SessionManager通过setSessionIdCookie()方法设置了个SimpleCookie,该类解决nginx分发访问时不同tomcat的sessionID不一致导致获取不到session的问题

    //解决nginx分发时出现There is no session with id ....的session不一致,找不到的问题
    @Bean("simpleCookie")
    public SimpleCookie getSimpleCookie (){
        SimpleCookie simpleCookie = new SimpleCookie(SHIRO_SESSION);
        simpleCookie.setPath("/");
        return simpleCookie;
    }

缓存管理器
CacheManager
而cache多例不需要交由spring管理,只需配置CacheManager

    //配置缓存
    @Bean("redisCacheManager")
    public MyRedisCacheManager getRedisCacheManager() {
        MyRedisCacheManager redisCacheManager = new MyRedisCacheManager();
        return redisCacheManager;
    }

各类实现代码

由以上配置可以看出需要实现的类其实只有三个,分别为SessionDao,CacheManager,Cache.代码如下:

SessionDao



import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.Serializable;
import java.util.*;

public class MyRedisSessionDao extends AbstractSessionDAO {
    private Object lock = new Object();
    public static final String SESSION_KEY = "session_key";

    //基于RedisTemplate集成工具类
    @Autowired
    private RedisUtil redisUtil;
    //删除session,退出时会调用到该方法
    @Override
    public void delete(Session session) {
        if(session == null || session.getId() == null){
            System.out.println("Session is null");
            return;
        }
        redisUtil.hdel(SESSION_KEY,session.getId().toString());
    }
    //获得sessin集合
    @Override
    public Collection<Session> getActiveSessions() {

        List<Session> list = new ArrayList<>();
        List<Object> objects = redisUtil.hgetList(SESSION_KEY);
        for (Object object : objects) {
            Session session = null;
            Base64 base64 = new Base64();
            try {
                byte[] decode = base64.decode((String) object);
                session = (Session) JSONUtil.unSerialize(decode);
            } catch (Exception e) {
                e.printStackTrace();
            }
            list.add(session);
        }
        return list;
    }
    //更新session
    @Override
    public void update(Session session) throws UnknownSessionException {
        this.saveSession(session);
    }
    private void saveSession(Session session){
        if(session == null || session.getId() == null){
            System.out.println("Session is null");
            return;
        }
        //添加进redis
        Base64 base64 = new Base64();
        String sessionStr = base64.encodeToString(JSONUtil.serialize(session));
        redisUtil.hset(SESSION_KEY,session.getId().toString(),sessionStr);
    }
     //shiro框架创建session的方法,shiro通过doReadSession得到空的session得知当前会话还没有session就会去创建session
    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = generateSessionId(session);
        assignSessionId(session, sessionId);
        //添加进redis
        this.saveSession(session);
        return sessionId;
    }
    //获取shiro框架session的方法
    @Override
    protected Session doReadSession(Serializable sessionId) {
        Session session = null;
        String sessionStr = (String) redisUtil.hget(SESSION_KEY, sessionId.toString());
        if(StringUtils.isNotEmpty(sessionStr)){
            Base64 base64 = new Base64();
                try {
                    synchronized (lock){
                        byte[] decode = base64.decode(sessionStr);
                        session = (Session) JSONUtil.unSerialize(decode);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
        }
        System.out.println("get sessionId:  "+sessionId + "session:  "+ session);
        return session;
    }
}

说明

RedisUtil
这个类基于RedisTemplate集成的工具类,对RedisTemplate的简单封装,主要功能就是基于redis对数据进行增删改查,由于本篇关注点不在此,就不展开了.如何配置RedisTemplate请自行百度.
Base64
为什么要使用Base64转码呢?说来话长,首先是这个Session实现类的问题,shiro对session的默认实现类是org.apache.shiro.session.mgt.SimpleSession这个类.我使用RedisTemplate<String,Object>来进行存取时(内部使用jackson来实现object与string相互转转换,redis只能存储字符串),会报错如下图:

jackson报错

究其原因,可能是SimpleSession中有个isValid()的方法,却没有valid字段,导致jackson创建类时报错.
解决这个问题的方法有很多种,我决定绕过jackson,自己实现session与string互相转换,于是使用java的对象序列化,转换成字节数组,再用base64转换成字符串,如上面代码的saveSession()方法,其中JSONUtil的相关代码如下:

    /**
     序列化对象
     @param object
     @return
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            if (object != null){
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                return baos.toByteArray();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**

     反序列化对象
     @param bytes
     @return
     */
    public static  Object unSerialize(byte[] bytes) throws Exception{
        ByteArrayInputStream bais = null;

            if (bytes != null && bytes.length > 0){
                bais = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            }
        return null;
    }

本以为万事大吉却还是报错,错误的大体问题是在doReadSession()方法中unSerialize反序列化时出现错误,内部原因暂时不知.但经过排查,主要是由于doReadSession存在着并发调用,在并发情况下java对象流处理时会出错!?本人并没有做更多的测试,同时百度无果.于是就加了个锁解决并发报错的问题,希望有大佬能解答这个疑惑!

ps

为什么不选则其他JSON工具类而使用java序列化呢?
答:实在是束手无策,诸如fastjson,gson都会报错,SimpleSession这个类真滴有毒,恨不得自定义,但是根据时下流行奥卡姆剃刀原则,还是惰性一点好,搞不好又是一堆bug.
而这个类的一些属性被transient关键字所修饰,如下图:

SimpleSession

最大的问题就是这个类,剩下的两个类就简单了;

CacheManager

import com.zoan.jdcbj.utils.RedisUtil;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class MyRedisCacheManager implements CacheManager {
    @Autowired
    private RedisUtil redisUtil;
    private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<>();
    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        Cache cache = caches.get(name);
        if (cache == null) {
            cache = new RedisCache(redisUtil);
            caches.put(name, cache);
        }
        return cache;
    }
}

内部存在一个map来存储Cache

Cache

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.*;

public class RedisCache<K, V> implements Cache<K, V> {
    private RedisUtil redisUtil;
    private RedisTemplate<String, Object> redisTemplate;

    public RedisCache(RedisUtil redisUtil) {
        this.redisUtil = redisUtil;
    }

    private static final String CACHE_KEY = "cache_key";

    @Override
    public V get(K key) throws CacheException {
        return (V) redisUtil.hget(CACHE_KEY,key.toString());
    }

    @Override
    public V put(K key, V value) throws CacheException {
        redisUtil.hset(CACHE_KEY,key.toString(),value);
        return value;
    }

    @Override
    public V remove(K key) throws CacheException {
        Object value = redisUtil.hget(CACHE_KEY, key.toString());
        redisUtil.hdel(CACHE_KEY,key.toString());
        return (V) value;
    }

    @Override
    public void clear() throws CacheException {
        Set<K> keys = keys();
        for (K key : keys) {
            redisUtil.hdel(CACHE_KEY,key.toString());
        }
    }
    @Override
    public int size() {
        return keys().size();
    }
    @Override
    public Set<K> keys() {
        Set<Object> objects = redisUtil.hgetKeys(CACHE_KEY);
        Set<K> keys  = new HashSet<>();
        for (Object object : objects) {
            keys.add((K) object);
        }
        return keys;
    }
    @Override
    public Collection<V> values() {
        List<Object> objects = redisUtil.hgetList(CACHE_KEY);
        List<V> list = new ArrayList<>();
        for (Object object : objects) {
           list.add((V)object);
        }
        return list;
    }
}

顾名思义,不做赘述;

其他

nginx的配置没什么特别之处,就不展示了;

总结

其实整合的过程并不难,需要理解的概念也很简单,但是问题在于坑实在有点多,主要体现在:

simpleSession使用redis存取时对象和字符串转换问题
nginx分发时session不一致问题

这两个问题结合shiro框架会引发许多bug值得注意;