基于redis实现tomcat8的tomcat集群的session持久化实现（tomcat-redis-session-manager二次开发）

前言：

本项目是基于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"/>