Apache-Shiro+Zookeeper系统集群安全解决方案之会话管理
如今的系统多不是孤军奋战，在多结点会话共享管理方面有着各自的解决办法，比如Session粘连，基于Web容器的各种处理等或者类似本文说的完全接管Web容器的Session管理，只是做法不尽相同。
而本文说的是Apache-Shiro+Zookeeper来解决多结点会话管理，Shiro一个优秀的权限框架，有着很好的扩展性，而Zookeeper更是让你激动不已的多功能分布式协调系统，在本例中就用它来做Shiro的会话持久容器！
在有过Shiro和Zookeeper开发后这一切都非常容易理解，实现过程如下：
用到的框架技术：
Spring + Shiro + Zookeeper
如今的系统多不是孤军奋战，在多结点会话共享管理方面有着各自的解决办法，比如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伪代码：
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>();
//读取所有SessionID , 返回形如: session-9e3b5707-fa80-4d32-a6c9-f1c3685263a5
List<String> ss = zookeeperTemplate.getChildren(zNode);
for (String id : ss) {
if (id.startsWith(sessionPrefix)) {
String noPrefixId = id.replace(sessionPrefix, "");
Session session = doReadSession(noPrefixId);
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的缓存共享管理。
