Session对象的持久化比较麻烦，虽然有序列化，但是并不确定Session对象中保存的其他信息是否可以序列化，这可能是网上很多解决方案摒弃此种做法的原因，网上的很多做法都是将Session中的attribute信息持久化并结构化存储，这显然很方便，但是session中的其他信息就丢了，否则仍然占据中间件内存，通过查看源码，惊喜的发现Tomcat对象提供了Session序列化的接口以及相关实现（Store），不过不是很满足需求，对其进行了一些改造就ok了，最终，Session对象作为一个整体，以二进制的形式保存在blob中，当反序列化时，还要装配Session和SessionManager之间的依赖关系。主要用到了session的以下方法，主要思想就是将session化整为零，传入一个输入流，将属性都写入该流中：
protected void writeObject(ObjectOutputStream stream) throws IOException {
// Write the scalar instance variables (except Manager)
stream.writeObject(new Long(creationTime));
stream.writeObject(new Long(lastAccessedTime));
stream.writeObject(new Integer(maxInactiveInterval));
stream.writeObject(new Boolean(isNew));
stream.writeObject(new Boolean(isValid));
stream.writeObject(new Long(thisAccessedTime));
stream.writeObject(id);
if (manager.getContainer().getLogger().isDebugEnabled())
manager.getContainer().getLogger().debug
("writeObject() storing session " + id);
// Accumulate the names of serializable and non-serializable attributes
String keys[] = keys();
ArrayList saveNames = new ArrayList();
ArrayList saveValues = new ArrayList();
for (int i = 0; i < keys.length; i++) {
Object value = attributes.get(keys[i]);
if (value == null)
continue;
else if ( (value instanceof Serializable)
&& (!exclude(keys[i]) )) {
saveNames.add(keys[i]);
saveValues.add(value);
} else {
removeAttributeInternal(keys[i], true);
}
}
// Serialize the attribute count and the Serializable attributes
int n = saveNames.size();
stream.writeObject(new Integer(n));
for (int i = 0; i < n; i++) {
stream.writeObject((String) saveNames.get(i));
try {
stream.writeObject(saveValues.get(i));
if (manager.getContainer().getLogger().isDebugEnabled())
manager.getContainer().getLogger().debug
(" storing attribute '" + saveNames.get(i) +
"' with value '" + saveValues.get(i) + "'");
} catch (NotSerializableException e) {
manager.getContainer().getLogger().warn
(sm.getString("standardSession.notSerializable",
saveNames.get(i), id), e);
stream.writeObject(NOT_SERIALIZED);
if (manager.getContainer().getLogger().isDebugEnabled())
manager.getContainer().getLogger().debug
(" storing attribute '" + saveNames.get(i) +
"' with value NOT_SERIALIZED");
}
}
}
这样将这个流的数据转换为一个字节流保存为blob即可。还原时，同样使用以下方法还原，将该流传入，方法会返回一个离线的Session对象，什么叫离散的？就是没有和具体的SessionMananger关联的：
protected void readObject(ObjectInputStream stream)
throws ClassNotFoundException, IOException { // Deserialize the scalar instance variables (except Manager)
authType = null; // Transient only
creationTime = ((Long) stream.readObject()).longValue();
lastAccessedTime = ((Long) stream.readObject()).longValue();
maxInactiveInterval = ((Integer) stream.readObject()).intValue();
isNew = ((Boolean) stream.readObject()).booleanValue();
isValid = ((Boolean) stream.readObject()).booleanValue();
thisAccessedTime = ((Long) stream.readObject()).longValue();
principal = null; // Transient only
// setId((String) stream.readObject());
id = (String) stream.readObject();
if (manager.getContainer().getLogger().isDebugEnabled())
manager.getContainer().getLogger().debug
("readObject() loading session " + id); // Deserialize the attribute count and attribute values
if (attributes == null)
attributes = new Hashtable();
int n = ((Integer) stream.readObject()).intValue();
boolean isValidSave = isValid;
isValid = true;
for (int i = 0; i < n; i++) {
String name = (String) stream.readObject();
Object value = (Object) stream.readObject();
if ((value instanceof String) && (value.equals(NOT_SERIALIZED)))
continue;
if (manager.getContainer().getLogger().isDebugEnabled())
manager.getContainer().getLogger().debug(" loading attribute '" + name +
"' with value '" + value + "'");
attributes.put(name, value);
}
isValid = isValidSave; if (listeners == null) {
listeners = new ArrayList();
} if (notes == null) {
notes = new Hashtable();
}
}
说说我为什么实现以上三种缓存方案。
最开始我通过Map缓存（SessionCacheMap）测试通过之后，立刻将其迁移到MemCache中，因为Map缓存还是属于JVM进程内缓存，Session仍然在中间件内部，只是保存在我自定义的一块内存区域中而已，只是验证是否可以完全的拦截，因此没有实际意义，需要将其从JVM内部拿出来。因此我迁移至MemCache中去了。
而为什么最后没有使用MemCache，MemCache没有保障，这个缓存性能很高，功能强大，但是它并不对缓存信息持久化，一旦它宕掉，session信息就都丢了，如果一些页面缓存丢了倒也没什么，重启再建立就好了，但是如果session信息丢了，那就比较严重了，而且这个缓存没有持久化方案，所以，最后我没有采用它缓存session，而是使用它来缓存页面。
所以我选择了dbms来存储session信息，dbms强大、可靠的数据管理保证session不会丢失，每个session都被持久化进数据库中，上个例子我们可以看到，我们把所有节点都关闭再启动，客户端刷新界面，仍然可以正常显示，session不会丢失。
可靠性有了保证，获取session是一个非常频繁的操作，如何保证性能呢？每次都去查询数据库，性能还是没有保证，这地方很容易成为瓶颈，尤其大规模访问时，虽然oracle可以将记录保存在buffercache中，但是毕竟它不是专业的缓存， bufferCache大小有限，而且每次插入删除session信息会涉及到磁盘的读写，这都是瓶颈，所以，我又引入了timesten内存数据库，它在Oracle的前端作为Oracle的一个超大的bufferCache，session持久化信息首先进入timesten，而timesten后台异步将session持久化至oracle中， TimeSten其实就是一个大的前端缓存而已，进一步讲，就是一个外置的bufferCache，后端的Oracle保证TimeSten万一宕掉，持久化的session数据不会丢失，宕掉就宕掉了，重启就ok了。所以，我在TimeSten11g版本下搭建了环境，建立了一个AWT类型的CacheGroup这个Cache就缓存了一张表名为T_SESSION：这张表的定义为：
create table T_SESSION
(
C_SID VARCHAR2(200) primary key ,
C_SESSION BLOB
)
基于这张表的CacheGroup我定义如下（oracle的blob在timesten中影射为varbinary）：
create dynamic asynchronous writethrough cache group g_awt from uss.t_session ( c_sid varchar(200) not null , c_session varbinary(262144),primary key(c_sid));
该Group采用异步方式写入oracle，数据的插入、删除都在timesten中完成，而timesten会异步的将数据刷新至oracle，看下例子：
首先在tt中插入1条数据：
再看下oracle中：
Timesten中删掉一条记录：
再看oracle中：
发现数据已经被异步更新。因此，采用timesten缓存session，oracle持久化session的基础环境已经OK了。下面其实就是将原本往oracle中保存的session往timesten中保存即可，其实就是切换一下Connection来源即可，此处省略。
那么如何处理session失效的问题？tomcat的session有一个lifescycle的概念，但是现在我把session对象从tomcat中完全剥离出来了，这样便不能由tomcat来维护了，怎么办呢？其实很简单，方案有两种：
1.我在t_session表的后面增加了d_create一列，类型为timestamp，该列代表这个session对象的创建时间戳，当session创建时记录时间戳，当session被修改时，更新这个时间戳，我定义一个job，这个job每5秒钟扫描一遍t_session记录，将截至到现在d_create超过某值的记录删除：
Delete from t_session where sysdate-c_create>n;这个n就是session的失效时间。
2.如果使用内存数据库，那更简单了，在文档中发现timesten有aging的概念，什么叫aging？看下面的CacheGroup定义：
create dynamic asynchronous writethrough cache group g_awt from uss.t_session ( c_sid varchar(200) not null , c_session varbinary(262144),d_create timestamp,primary key(c_sid)) AGING USE d_create LIFETIME 15 minutes CYCLE 5 seconds ON;
aging子句代表每隔6秒钟检测一次记录，使d_create超过15分钟的记录失效，是不是很方便？交给timesten去维护就ok了。
再说说我是如何实现页面缓存的，页面缓存使用Filter来实现，包装了ResponseWrapper类，该类拦截response的信息，将中间件的响应数据拦截并保存至MemCache中，当下次同样的URL到来，只需要去MemCache中取就可以了。
PageCacheFilter用于拦截url，将指定规则的url拦截响应内容并缓存至MemCache，其中具体的是由MonitorResponseWrapper类来完成的，中间件的响应数据存储在它的ByteArray输出流中，它继承自HttpServletResponseWrapper类,典型的装饰模式的应用。
package com.thunisoft.filter; import java.io.IOException;
import java.util.Date; import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; public class PageCacheFilter implements Filter { public void destroy() {
// TODO Auto-generated method stub } public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
MonitorResponseWrapper response = new MonitorResponseWrapper(
(HttpServletResponse) resp);
String url = ((HttpServletRequest) req).getRequestURI();
// MemCachedManager.getInstance().delete(url);
Object o = MemCachedManager.getInstance().get(url);
Date d = new Date(System.currentTimeMillis() + 10000);
if (o == null) {
chain.doFilter(req, response);
byte b[] = response.getResponseData();
resp.getOutputStream().write(b);
MemCachedManager.getInstance().set(url, b, d);
} else {
byte[] b = (byte[]) o;
resp.getOutputStream().write(b);
} } public static void main(String[] args) {
Date d = new Date(500);
} public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub } }
package com.thunisoft.filter; import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException; import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper; public class MonitorResponseWrapper extends HttpServletResponseWrapper { private ByteArrayOutputStream buffer = null;
private ServletOutputStream out = null;
private PrintWriter writer = null; public MonitorResponseWrapper(HttpServletResponse resp) throws IOException {
super(resp);
buffer = new ByteArrayOutputStream();// 真正存储数据的流
out = new WapperedOutputStream(buffer);
writer = new PrintWriter(new OutputStreamWriter(buffer, this
.getCharacterEncoding()));
} // 重载父类获取outputstream的方法
@Override
public ServletOutputStream getOutputStream() throws IOException {
return out;
} // 重载父类获取writer的方法
@Override
public PrintWriter getWriter() throws UnsupportedEncodingException {
return writer;
} // 重载父类获取flushBuffer的方法
@Override
public void flushBuffer() throws IOException {
if (out != null) {
out.flush();
}
if (writer != null) {
writer.flush();
}
} static int i; public static void main(String[] args) { System.out.println(i);
} @Override
public void reset() {
buffer.reset();
} public byte[] getResponseData() throws IOException {
// 将out、writer中的数据强制输出到WapperedResponse的buffer里面，否则取不到数据
flushBuffer();
return buffer.toByteArray();
} // 内部类，对ServletOutputStream进行包装
private class WapperedOutputStream extends ServletOutputStream {
private ByteArrayOutputStream bos = null; public WapperedOutputStream(ByteArrayOutputStream stream)
throws IOException {
bos = stream;
} @Override
public void write(int b) throws IOException {
bos.write(b);
}
}
}
package com.thunisoft.filter; import java.util.Date; import org.apache.catalina.Session; import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.thunisoft.session.CachedSession; /**
*
* Memcached 缓存管理
*
* @author Administrator
*
*
*/
public class MemCachedManager {
// 创建全局的唯一实例
protected static MemCachedClient mcc = new MemCachedClient();
protected static MemCachedManager memCachedManager = new MemCachedManager();
// 设置与缓存服务器的连接池
static {
// 服务器列表和其权重
String[] servers = { "172.20.70.251:12000" };
Integer[] weights = { 3 };
// 获取socke连接池的实例对象
SockIOPool pool = SockIOPool.getInstance();
// 设置服务器信息
pool.setServers(servers);
pool.setWeights(weights);
// 设置初始连接数、最小和最大连接数以及最大处理时间
pool.setInitConn(5);
pool.setMinConn(5);
pool.setMaxConn(250);
pool.setMaxIdle(1000 * 60 * 60 * 6);
// 设置主线程的睡眠时间
pool.setMaintSleep(30);
// 设置TCP的参数，连接超时等
pool.setNagle(false);
pool.setSocketTO(3000);
pool.setSocketConnectTO(0);
// 初始化连接池
pool.initialize();
// 压缩设置，超过指定大小（单位为K）的数据都会被压缩
mcc.setCompressEnable(true);
mcc.setCompressThreshold(64 * 1024);
} /**
*
* 保护型构造方法，不允许实例化！
*
*
*/
protected MemCachedManager() {
} /**
*
* 获取唯一实例.
*
*
*
* @return
*/
public synchronized static MemCachedManager getInstance() {
return memCachedManager;
} /**
*
* 添加一个指定的值到缓存中.
*
*
*
* @param key
*
* @param value
*
* @return
*/
public boolean add(String key, Object value) {
return mcc.add(key, value);
} public boolean add(String key, Object value, Date expiry) {
return mcc.add(key, value, expiry);
} public boolean set(String key, Object value, Date expiry) { return mcc.set(key, value, expiry); }
public boolean set(String key, Object value) { return mcc.set(key, value); } /**
*
* 更新缓存对象
*
* @param key
*
* @param value
*
* @return
*/
public boolean replace(String key, Object value) {
return mcc.replace(key, value);
} public boolean replace(String key, Object value, Date expiry) {
return mcc.replace(key, value, expiry);
} /**
*
* 根据指定的关键字获取对象.
*
*
*
* @param key
*
* @return
*/
public Object get(String key) {
return mcc.get(key);
}
public boolean delete(String key){
return mcc.delete(key);
} public static void main(String[] args) { MemCachedManager cache = MemCachedManager.getInstance();
Session s=new CachedSession(null,null);
cache.set("111",s, new Date(System.currentTimeMillis()+10*1000));
// Object o=cache.get("E4A8127405876F0F94627BB0F440CCDC"); System.out.println("get value : " + cache.get("111"));
}
}
package com.thunisoft.filter; import java.util.Date; import org.apache.catalina.Session; import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.thunisoft.session.CachedSession; /**
*
* Memcached 缓存管理
*
* @author Administrator
*
*
*/
public class MemCachedManager {
// 创建全局的唯一实例
protected static MemCachedClient mcc = new MemCachedClient();
protected static MemCachedManager memCachedManager = new MemCachedManager();
// 设置与缓存服务器的连接池
static {
// 服务器列表和其权重
String[] servers = { "172.20.70.251:12000" };
Integer[] weights = { 3 };
// 获取socke连接池的实例对象
SockIOPool pool = SockIOPool.getInstance();
// 设置服务器信息
pool.setServers(servers);
pool.setWeights(weights);
// 设置初始连接数、最小和最大连接数以及最大处理时间
pool.setInitConn(5);
pool.setMinConn(5);
pool.setMaxConn(250);
pool.setMaxIdle(1000 * 60 * 60 * 6);
// 设置主线程的睡眠时间
pool.setMaintSleep(30);
// 设置TCP的参数，连接超时等
pool.setNagle(false);
pool.setSocketTO(3000);
pool.setSocketConnectTO(0);
// 初始化连接池
pool.initialize();
// 压缩设置，超过指定大小（单位为K）的数据都会被压缩
mcc.setCompressEnable(true);
mcc.setCompressThreshold(64 * 1024);
} /**
*
* 保护型构造方法，不允许实例化！
*
*
*/
protected MemCachedManager() {
} /**
*
* 获取唯一实例.
*
*
*
* @return
*/
public synchronized static MemCachedManager getInstance() {
return memCachedManager;
} /**
*
* 添加一个指定的值到缓存中.
*
*
*
* @param key
*
* @param value
*
* @return
*/
public boolean add(String key, Object value) {
return mcc.add(key, value);
} public boolean add(String key, Object value, Date expiry) {
return mcc.add(key, value, expiry);
} public boolean set(String key, Object value, Date expiry) { return mcc.set(key, value, expiry); }
public boolean set(String key, Object value) { return mcc.set(key, value); } /**
*
* 更新缓存对象
*
* @param key
*
* @param value
*
* @return
*/
public boolean replace(String key, Object value) {
return mcc.replace(key, value);
} public boolean replace(String key, Object value, Date expiry) {
return mcc.replace(key, value, expiry);
} /**
*
* 根据指定的关键字获取对象.
*
*
*
* @param key
*
* @return
*/
public Object get(String key) {
return mcc.get(key);
}
public boolean delete(String key){
return mcc.delete(key);
} public static void main(String[] args) { MemCachedManager cache = MemCachedManager.getInstance();
Session s=new CachedSession(null,null);
cache.set("111",s, new Date(System.currentTimeMillis()+10*1000));
// Object o=cache.get("E4A8127405876F0F94627BB0F440CCDC"); System.out.println("get value : " + cache.get("111"));
}
}
所以，最终，这个方案的整体架构如下：
这个架构的优点有以下：
使用廉价的Tomcat集群，摒弃了效率低下的session复制，可以实现大规模的横向扩展，增加网站的吞吐量和并发访问量，如果网站的并发访问超大，那么可以对前端的Apache进行分层的扩展，也很简单，未来Session如果更多的话，那Timsten的查询可能会成为瓶颈，那可以继续将TimeSten拆分，在tomcat的会话管理器中对Session查询进行路由，比如对sessionid进行hash散列，将session分散缓存至分布式的TimeSten中，客户端请求时，根据hash映射确定sessionid存在于哪个TimeSten节点中，达到分散压力的目的，这只是对于一般网站，如果对于mis系统，可能最终的压力都跑到数据库上而非中间件了，那又是另外一回事了。