wayne_liberary / Shiro / Apache

分享

   

Apache

2015-06-14  wayne_lib...

如今的系统多不是孤军奋战,在多结点会话共享管理方面有着各自的解决办法,比如Session粘连,基于Web容器的各种处理等或者类似本文说的完全接管Web容器的Session管理,只是做法不尽相同。

而本文说的是Apache-Shiro+Zookeeper来解决多结点会话管理,Shiro一个优秀的权限框架,有着很好的扩展性,而Zookeeper更是让你激动不已的多功能分布式协调系统,在本例中就用它来做Shiro的会话持久容器!

在有过Shiro和Zookeeper开发后这一切都非常容易理解,实现过程如下:

用到的框架技术:

Spring + Shiro + Zookeeper

第一步:配置WEB.XML
<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
        <param-name>targetFilterLifecycle</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
第二步:SHIRO整合SPRING配置

applicationContext-shiro.xml 伪代码:

<!--Session集群配置-->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    <property name="globalSessionTimeout" value="3600000"/>
    <property name="sessionDAO" ref="zkShiroSessionDAO"/>
    <property name="sessionValidationScheduler" ref="sessionValidationScheduler"/>
    <property name="sessionValidationSchedulerEnabled" value="true"/>
    <property name="sessionIdCookie" ref="wapsession"/>
</bean>

<!--
指定本系统SESSIONID, 默认为: JSESSIONID
问题: 与SERVLET容器名冲突, 如JETTY, TOMCAT 等默认JSESSIONID,
当跳出SHIRO SERVLET时如ERROR-PAGE容器会为JSESSIONID重新分配值导致登录会话丢失!
-->
<bean id="wapsession" class="org.apache.shiro.web.servlet.SimpleCookie">
    <constructor-arg name="name" value="WAPSESSIONID"/>
</bean>

<!--
定时清理僵尸session,Shiro会启用一个后台守护线程定时执行清理操作
用户直接关闭浏览器造成的孤立会话
-->
<bean id="sessionValidationScheduler"
      class="org.apache.shiro.session.mgt.ExecutorServiceSessionValidationScheduler">
    <property name="interval" value="3600000"/>
    <property name="sessionManager" ref="sessionManager"/>
</bean>

<!--由zk做session存储容器-->
<bean id="zkShiroSessionDAO" class="b2gonline.incometaxexamine._systembase.shiro.ZKShiroSessionDAO">
    <!--使用内存缓存登录用户信息,一次获取用户登录信息后缓存到内存减少Shiro大量的读取操作,用户退出或超时后自动清除-->
    <constructor-arg name="useMemCache" value="true"/>    
    <property name="zookeeperTemplate" ref="zookeeperTemplate"/>
    <property name="shiroSessionZKPath" value="/SHIROSESSIONS"/>
    <property name="sessionPrefix" value="session-"/>
</bean>

<!-- SHIRO安全接口 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    ...
    <property name="sessionManager" ref="sessionManager"/>
</bean>
第三步:Zookeeper对Shiro-SessionDao实现类

ZKShiroSessionDAO.JAVA伪代码:

package b2gonline.incometaxexamine._systembase.shiro;

import bgonline.foundation.hadoop.zk.IZookeeperTemplate;
import bgonline.foundation.hadoop.zk.ZNode;
import org.apache.shiro.cache.AbstractCacheManager;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.MapCache;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.apache.shiro.session.mgt.eis.CachingSessionDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.SerializationUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ZOOKEEPER实现SHIRO集群SESSION存储
 *
 * @author aliencode
 * @date 13-7-10
 */
public class ZKShiroSessionDAO extends CachingSessionDAO {

    public ZKShiroSessionDAO() {
    }

    private boolean useMemCache = false;

    /**
     * SESSION ZK DAO 实例
     * 如果开启缓存
     * 用户登录时自动缓存, 用户登录超时自动删除
     * 由于shiro的cacheManager是全局的, 所以这里使用setActiveSessionsCache直接设置Cache来本地缓存, 而不使用全局zk缓存.
     * 由于同一用户可能会被路由到不同服务器,所以在doReadSession方法里也做了缓存增加.
     *
     * @param useMemCache 是否使用内存缓存登录信息
     */
    public ZKShiroSessionDAO(boolean useMemCache) {
        this.useMemCache = useMemCache;
        if (useMemCache) {
            setActiveSessionsCache(
                    new MapCache<>(this.ACTIVE_SESSION_CACHE_NAME, new ConcurrentHashMap<Serializable, Session>())
            );
        }
    }

    Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * ZK操作类
     */
    private IZookeeperTemplate zookeeperTemplate;

    /**
     * 缓存根路径
     */
    private String shiroSessionZKPath = "/SHIROSESSIONS";

    /**
     * 缓存项前缀
     */
    private String sessionPrefix = "session-";

    /**
     * 设置Shiro Session 前缀 默认 session-
     *
     * @param sessionPrefix
     */
    public void setSessionPrefix(String sessionPrefix) {
        this.sessionPrefix = sessionPrefix;
    }


    public void setZookeeperTemplate(IZookeeperTemplate zookeeperTemplate) {
        this.zookeeperTemplate = zookeeperTemplate;
    }

    /**
     * 设置Shiro在ZK服务器存放根路径
     *
     * @param shiroSessionZKPath 默认值:/SHIROSESSIONS
     */
    public void setShiroSessionZKPath(String shiroSessionZKPath) {
        this.shiroSessionZKPath = shiroSessionZKPath;
    }

    /**
     * session更新
     *
     * @param session
     * @throws UnknownSessionException
     */
    @Override
    public void update(Session session) throws UnknownSessionException {
        if (session == null || session.getId() == null) {
            logger.error("session argument cannot be null.");
        }
        saveSession(session, "update");
    }

    @Override
    protected void doUpdate(Session session) {
    }

    /**
     * session删除
     *
     * @param session
     */
    @Override
    public void delete(Session session) {
        if (session == null || session.getId() == null) {
            logger.error("session argument cannot be null.");
        }
        logger.debug("delete session for id: {}", session.getId());
        zookeeperTemplate.deleteNode(getPath(session.getId()));
        if (useMemCache) {
            this.uncache(session);
        }
    }

    @Override
    protected void doDelete(Session session) {
    }

    /**
     * 获取当前活跃的session, 当前在线数量
     *
     * @return
     */
    @Override
    public Collection<Session> getActiveSessions() {
        ZNode zNode = new ZNode();
        zNode.setPath(shiroSessionZKPath);
        Set<Session> sessions = new HashSet<Session>();
        List<String> ss = zookeeperTemplate.getChildren(zNode);
        for (String id : ss) {
            Session session = doReadSession(id);
            if (session != null)
                sessions.add(session);
        }
        logger.debug("shiro getActiveSessions. size: {}", sessions.size());
        return sessions;
    }

    /**
     * 创建session, 用户登录
     *
     * @param session
     * @return
     */
    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = this.generateSessionId(session);
        this.assignSessionId(session, sessionId);
        saveSession(session, "create");
        return sessionId;
    }

    /**
     * session读取
     *
     * @param id
     * @return
     */
    @Override
    protected Session doReadSession(Serializable id) {
        if (id == null) {
            logger.error("id is null!");
            return null;
        }
        logger.debug("doReadSession for path: {}", getPath(id));

        Session session;
        byte[] byteData = zookeeperTemplate.getData(getPath(id)).getByteData();
        if (byteData != null && byteData.length > 0) {
            session = (Session) SerializationUtils.deserialize(byteData);
            if (useMemCache) {
                this.cache(session, id);
                logger.debug("doReadSession for path: {}, add cached !", getPath(id));
            }
            return session;
        } else {
            return null;
        }
    }

    /**
     * 生成全路径
     *
     * @param sessID
     * @return
     */
    private String getPath(Serializable sessID) {
        return shiroSessionZKPath + '/' + sessionPrefix + sessID.toString();
    }

    /**
     * session读取或更新
     *
     * @param session
     * @param act     update/save
     */
    private void saveSession(Session session, String act) {
        Serializable sessionId = session.getId();
        ZNode sessionNode = new ZNode();
        sessionNode.setByteData(SerializationUtils.serialize(session));
        sessionNode.setPath(getPath(sessionId));
        logger.debug("save session for id: {}, act: {}", sessionId, act);
        if (act == "update")
            zookeeperTemplate.setData(sessionNode);
        else
            zookeeperTemplate.createNode(sessionNode);
    }
}
小结

本文主要给出会话管理的实现过程和部分核心代码,并且说到并解决了在使用Shiro开发时会遇到的几个关键问题和心得,如

Shiro默认的JSESSIONID和WEB容器同名冲突,这个如果使用默认开发时当访问404等错误页面由WEb容器直接处理并由生成新的JSESSIONID使得Shiro退出;

SESSION会话缓存,这个借鉴EnterpriseCacheSessionDAO,由于Shiro在访问每个链接时都会读取一次Session,所以在用户成功登录后把Session存储并缓存到内存或本地以减少大量读取操作;

孤立会话的清除,当用户直接关闭浏览器会有Session孤立于储存容器中,配置ExecutorServiceSessionValidationScheduler定时清理!

下一篇,有关Shiro的缓存共享管理。

完!

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多
    喜欢该文的人也喜欢 更多

    ×
    ×

    ¥.00

    微信或支付宝扫码支付:

    开通即同意《个图VIP服务协议》

    全部>>