前言：
本项目是基于jcoleman的tomcat-redis-session-manager二次开发版本
1、修改了小部分实现逻辑
2、去除对juni.jar包的依赖
3、去除无效代码和老版本tomcat操作API
4、支持tomcat 8 及以后的版本
感谢jcoleman的项目： https://github.com/jcoleman/tomcat-redis-session-manager，由于该项目已经停止更新，最新版本只支持tomcat7，对于tomcat7以后的版本都不支持。
源码提供：
github项目地址：https://github.com/eguid/tomcat-redis-sessioon-manager
下载目录：
tomcat-redis-session-manager-by-eguid.jar下载地址：http://download.csdn.net/detail/eguid_1/9638171
tomcat-redis-session-manager-by-eguid.jar+jedis-2.9.0.jar+commons-pool2-2.2.jar集合包下载
注意：本项目依赖5个jar包，tomcat-api.jar；catalina.jar；servlet-api.jar；jedis-2.9.0.jar；commons-pool-2.4.2.jar，其中tomcat-api.jar、catalina.jar和servlet-api.jar这三个包是tomcat原生jar包，本项目打包时不需要打入这三个包
一、主要代码实现
1、session管理器实现
该类用于实现session的基本增删改查操作，加入了redis实现持久化
package cn.eguid.redisSessionManager;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.util.LifecycleSupport;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.Valve;
import org.apache.catalina.Session;
import org.apache.catalina.session.ManagerBase;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Protocol;
import java.io.IOException;
import java.util.Arrays;
import java.util.Set;
/**
*
* @author eguid
*
*/
public class RedisSessionManager extends ManagerBase implements Lifecycle {
protected byte[] NULL_SESSION = "null".getBytes();
protected String host = "localhost";
protected int port = 6379;
protected int database = 0;
protected String password = null;
protected int timeout = Protocol.DEFAULT_TIMEOUT;
protected JedisPool connectionPool = null;
protected RedisSessionHandlerValve handlerValve;
protected ThreadLocal<RedisSession> currentSession = new ThreadLocal<RedisSession>();
protected ThreadLocal<String> currentSessionId = new ThreadLocal<String>();
protected ThreadLocal<Boolean> currentSessionIsPersisted = new ThreadLocal<Boolean>();
protected Serializer serializer;
protected static String name = "RedisSessionManager";
// 用于序列化的类
protected String serializationStrategyClass = "cn.eguid.redisSessionManager.JavaSerializer";
protected LifecycleSupport lifecycle = new LifecycleSupport(this);
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public int getDatabase() {
return database;
}
public void setDatabase(int database) {
this.database = database;
}
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public void setSerializationStrategyClass(String strategy) {
this.serializationStrategyClass = strategy;
}
@Override
public int getRejectedSessions() {
// Essentially do nothing.
return 0;
}
public void setRejectedSessions(int i) {
// Do nothing.
}
protected Jedis getConnection() {
System.out.println("获取jedis连接");
Jedis jedis = connectionPool.getResource();
if (getDatabase() != 0) {
jedis.select(getDatabase());
}
return jedis;
}
protected void returnConnection(Jedis jedis) {
System.out.println("注销jedis连接");
jedis.close();
}
@Override
public void load() throws ClassNotFoundException, IOException {
}
@Override
public void unload() throws IOException {
}
/**
* Add a lifecycle event listener to this component.
*
* @param listener
* The listener to add
*/
@Override
public void addLifecycleListener(LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
/**
* Get the lifecycle listeners associated with this lifecycle. If this
* Lifecycle has no listeners registered, a zero-length array is returned.
*/
@Override
public LifecycleListener[] findLifecycleListeners() {
return lifecycle.findLifecycleListeners();
}
/**
* Remove a lifecycle event listener from this component.
*
* @param listener
* The listener to remove
*/
@Override
public void removeLifecycleListener(LifecycleListener listener) {
lifecycle.removeLifecycleListener(listener);
}
/**
* Start this component and implement the requirements of
* {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
*
* @exception LifecycleException
* if this component detects a fatal error that prevents this
* component from being used
*/
@Override
protected synchronized void startInternal() throws LifecycleException {
boolean isSucc=false;
try {
System.out.println("准备开启redis-session-Manager处理器 ... ");
super.startInternal();
setState(LifecycleState.STARTING);
Boolean attachedToValve = false;
Valve[] values = getContainer().getPipeline().getValves();
for (Valve valve : values) {
if (valve instanceof RedisSessionHandlerValve) {
System.out.println("初始化redis-session-Manager处理器 ... ");
this.handlerValve = (RedisSessionHandlerValve) valve;
this.handlerValve.setRedisSessionManager(this);
attachedToValve = true;
break;
}
}
if (!attachedToValve) {
String error = "重大错误：redis-session-Manager无法添加到会话处理器，session在请求后不能正常启动处理器！";
throw new LifecycleException(error);
}
System.out.println("初始化序列化器和反序列化器 ... ");
initializeSerializer();
initializeDatabaseConnection();
setDistributable(true);
isSucc=true;
} catch (ClassNotFoundException e) {
throw new LifecycleException(e);
} catch (InstantiationException e) {
throw new LifecycleException(e);
} catch (IllegalAccessException e) {
throw new LifecycleException(e);
} catch(Exception e){
throw e;
}finally{
if(isSucc){
System.out.println("redis-session-manager初始化成功");
}else{
System.out.println("redis-session-manager初始化失败");
}
}
}
/**
* Stop this component and implement the requirements of
* {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
*
* @exception LifecycleException
* if this component detects a fatal error that prevents this
* component from being used
*/
@Override
protected synchronized void stopInternal() throws LifecycleException {
System.err.println("停止redis-session-manager处理器!");
setState(LifecycleState.STOPPING);
try {
if (connectionPool != null) {
connectionPool.destroy();
}
} catch (Exception e) {
System.err.println("注销redis连接池失败!");
connectionPool = null;
}
super.stopInternal();
}
@Override
public Session createSession(String sessionId) {
System.out.println("根据sessionId创建session:" + sessionId);
// 初始化设置并创建一个新的session返回
RedisSession session = (RedisSession) createEmptySession();
session.setNew(true);
session.setValid(true);
session.setCreationTime(System.currentTimeMillis());
session.setMaxInactiveInterval(getMaxInactiveInterval());
String jvmRoute = getJvmRoute();
Jedis jedis = null;
try {
jedis = getConnection();
do {
if (null == sessionId) {
// 重新生成一个sessionId
sessionId = generateSessionId();
}
if (jvmRoute != null) {
sessionId += '.' + jvmRoute;
}
} while (jedis.setnx(sessionId.getBytes(), NULL_SESSION) == 1L);
/*
* Even though the key is set in Redis, we are not going to flag the
* current thread as having had the session persisted since the
* session isn't actually serialized to Redis yet. This ensures that
* the save(session) at the end of the request will serialize the
* session into Redis with 'set' instead of 'setnx'.
*/
session.setId(sessionId);
session.tellNew();
currentSession.set(session);
currentSessionId.set(sessionId);
currentSessionIsPersisted.set(false);
} finally {
if (jedis != null) {
jedis.close();
}
}
return session;
}
@Override
public Session createEmptySession() {
System.out.println("添加空的session");
return new RedisSession(this);
}
@Override
public void add(Session session) {
System.out.println("添加session到redis数据库");
try {
save(session);
} catch (IOException e) {
throw new RuntimeException("保存session失败", e);
}
}
@Override
public Session findSession(String id) throws IOException {
System.out.println("查找sessionId:" + id);
RedisSession session = null;
if (id == null) {
session = null;
currentSessionIsPersisted.set(false);
} else if (id.equals(currentSessionId.get())) {
session = currentSession.get();
} else {
session = loadSessionFromRedis(id);
if (session != null) {
currentSessionIsPersisted.set(true);
}
}
currentSession.set(session);
currentSessionId.set(id);
return session;
}
public void clear() {
Jedis jedis = null;
try {
jedis = getConnection();
jedis.flushDB();
} finally {
if (jedis != null) {
jedis.close();
}
}
}
public int getSize() throws IOException {
Jedis jedis = null;
try {
jedis = getConnection();
int size = jedis.dbSize().intValue();
return size;
} finally {
if (jedis != null) {
jedis.close();
}
}
}
public String[] keys() throws IOException {
Jedis jedis = null;
try {
jedis = getConnection();
Set<String> keySet = jedis.keys("*");
return keySet.toArray(new String[keySet.size()]);
} finally {
if (jedis != null) {
jedis.close();
}
}
}
public RedisSession loadSessionFromRedis(String id) throws IOException {
RedisSession session;
Jedis jedis = null;
try {
jedis = getConnection();
byte[] data = jedis.get(id.getBytes());
if (data == null) {
session = null;
} else if (Arrays.equals(NULL_SESSION, data)) {
throw new IllegalStateException("Race condition encountered: attempted to load session[" + id
+ "] which has been created but not yet serialized.");
} else {
session = (RedisSession) createEmptySession();
serializer.deserializeInto(data, session);
session.setId(id);
session.setNew(false);
session.setMaxInactiveInterval(getMaxInactiveInterval() * 1000);
session.access();
session.setValid(true);
session.resetDirtyTracking();
}
return session;
} catch (IOException e) {
throw e;
} catch (ClassNotFoundException ex) {
throw new IOException("Unable to deserialize into session", ex);
} finally {
if (jedis != null) {
jedis.close();
}
}
}
/**
* save session to redis
*
* @param session
* @throws IOException
*/
public void save(Session session) throws IOException {
System.out.println("保存session到redis");
Jedis jedis = null;
try {
RedisSession redisSession = (RedisSession) session;
Boolean sessionIsDirty = redisSession.isDirty();
redisSession.resetDirtyTracking();
byte[] binaryId = redisSession.getId().getBytes();
jedis = getConnection();
if (sessionIsDirty || currentSessionIsPersisted.get() != true) {
jedis.set(binaryId, serializer.serializeFrom(redisSession));
}
currentSessionIsPersisted.set(true);
jedis.expire(binaryId, getMaxInactiveInterval());
} catch (IOException e) {
throw e;
} finally {
if (jedis != null) {
jedis.close();
}
}
}
@Override
public void remove(Session session) {
remove(session, false);
}
@Override
public void remove(Session session, boolean update) {
System.out.println("删除redis中的session，更新："+update);
Jedis jedis = null;
try {
jedis = getConnection();
jedis.del(session.getId());
} finally {
if (jedis != null) {
jedis.close();
}
}
}
public void afterRequest() {
System.out.println("删除缓存在内存中的session");
RedisSession redisSession = currentSession.get();
if (redisSession != null) {
currentSession.remove();
currentSessionId.remove();
currentSessionIsPersisted.remove();
}
}
@Override
public void processExpires() {
// We are going to use Redis's ability to expire keys for session
// expiration.
// Do nothing.
}
private void initializeDatabaseConnection() throws LifecycleException {
try {
System.out.println("初始化redis连接池 ... ");
// 初始化redis连接池
connectionPool = new JedisPool(new JedisPoolConfig(), getHost(), getPort(), getTimeout(), getPassword());
} catch (Exception e) {
e.printStackTrace();
throw new LifecycleException("redis连接池初始化错误，redis不存在或配置错误！", e);
}
}
private void initializeSerializer() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
System.out.println("准备初始化序列器 ... ");
serializer = (Serializer) Class.forName(serializationStrategyClass).newInstance();
ClassLoader classLoader = null;
if (getContainer() != null) {
classLoader = getContainer().getClass().getClassLoader();
}
System.out.println("初始化序列器完成！");
serializer.setClassLoader(classLoader);
}
}
2、redis的session实现
package cn.eguid.redisSessionManager;
import java.security.Principal;
import org.apache.catalina.Manager;
import org.apache.catalina.session.StandardSession;
import java.util.HashMap;
public class RedisSession extends StandardSession {
protected static Boolean manualDirtyTrackingSupportEnabled = false;
public static void setManualDirtyTrackingSupportEnabled(Boolean enabled) {
manualDirtyTrackingSupportEnabled = enabled;
}
protected static String manualDirtyTrackingAttributeKey = "__changed__";
public static void setManualDirtyTrackingAttributeKey(String key) {
manualDirtyTrackingAttributeKey = key;
}
protected HashMap<String, Object> changedAttributes;
protected Boolean dirty;
public RedisSession(Manager manager) {
super(manager);
resetDirtyTracking();
}
public Boolean isDirty() {
return dirty || !changedAttributes.isEmpty();
}
public HashMap<String, Object> getChangedAttributes() {
return changedAttributes;
}
public void resetDirtyTracking() {
changedAttributes = new HashMap<String, Object>();
dirty = false;
}
@Override
public void setAttribute(String key, Object value) {
if (manualDirtyTrackingSupportEnabled && manualDirtyTrackingAttributeKey.equals(key)) {
dirty = true;
return;
}
Object oldValue = getAttribute(key);
if ( value == null && oldValue != null
|| oldValue == null && value != null
|| !value.getClass().isInstance(oldValue)
|| !value.equals(oldValue) ) {
changedAttributes.put(key, value);
}
super.setAttribute(key, value);
}
@Override
public void removeAttribute(String name) {
dirty = true;
super.removeAttribute(name);
}
@Override
public void setId(String id) {
this.id = id;
}
@Override
public void setPrincipal(Principal principal) {
dirty = true;
super.setPrincipal(principal);
}
}
3、session处理器实现
该类可以用于在请求前后请求后做一些操作，不仅局限于session操作，可以做servlet中的所有操作
package cn.eguid.redisSessionManager;
import org.apache.catalina.Session;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.valves.ValveBase;
import javax.servlet.ServletException;
import java.io.IOException;
public class RedisSessionHandlerValve extends ValveBase {
// redis-session-manager管理器操作
private RedisSessionManager manager;
// 通过tomcat的context.xml可以注入该实例
public void setRedisSessionManager(RedisSessionManager manager) {
this.manager = manager;
}
// 产生一个请求后
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
try {
getNext().invoke(request, response);
} finally {
System.out.println("请求完毕后，redis-session-manager正在获取当前产生的session");
Session session = request.getSessionInternal(false);
storeOrRemoveSession(session);
System.out.println("redis-session-manager操作结束，正在清理内存中的session！");
// 删除内存中的session
manager.afterRequest();
}
}
private void storeOrRemoveSession(Session session) {
try {
if (session!=null && session.isValid() && session.getSession() != null) {
manager.save(session);
} else {
manager.remove(session);
}
} catch (Exception e) {
System.err.println("提示一下：session操作失败");
}
}
}
二、如何配置该项目到tomcat
1、拷贝tomcat-redis-session-manager-by-eguid.jar，jedis-2.9.0.jar，commons-pool2-2.2.jar到tomcat/lib目录下
2、修改Tomcat context.xml (or the context block of the server.xml if applicable.)
<Valve className="cn.eguid.redisSessionManager.RedisSessionHandlerValve"/>
<Manager className="cn.eguid.redisSessionManager.RedisSessionManager"
host="192.168.30.21"
port="6379"
database="14"
maxInactiveInterval="1800"/>