Session.java

package com.jiuqi.lbsinterface.ws.server;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import com.jiuqi.lbsinterface.bean.UserBean;
import com.jiuqi.lbsinterface.exception.LoginException;

public final class Session {
	private final static Session dsession = new Session();
	//
	/**
	 * session正常失效时间
	 */
	private final static long SessionOutTime = 100 * 60 * 1000;// 30分钟
	/**
	 * session最小失效时间，当服务器session缓存量达到系统的90%时，以此时间消耗session
	 * 
	 * @see 未实现
	 */
	private final static long SessionMinOutTime = 10 * 60000;// 10分钟
	private final static int maxSessionNumber = 10000;// session上线10000。
	//
	private final static ThreadLocal<Session> local = new ThreadLocal<Session>();
	private final static Object LOCK = new Object();
	private static Thread DaemonThread;

	// static {
	// initThread();
	// }

	private synchronized static void initThread() {
		if (null == DaemonThread || DaemonThread.isInterrupted()) {
			DaemonThread = new Thread(new Runnable() {
				private final List<String> removeList = new ArrayList<String>();
				private final int waitTime = 60000;
				private final int level = (int) (SessionMinOutTime / waitTime);
				private int time = 0;

				@Override
				public void run() {
					while (true) {
						synchronized (LOCK) {
							try {
								LOCK.wait(waitTime);
							} catch (InterruptedException e) {
								continue;
							}
						}
						if (time++ % level == 0) {
							synchronized (sessionMap) {
								for (Session s : sessionMap.values()) {
									if (System.currentTimeMillis() >= s.lastHaveTime
											+ SessionOutTime) {
										removeList.add(s.getSessionID());
									}
								}
							}
						}
						synchronized (removeList) {
							int size = removeList.size();
							for (int i = size - 1; i >= 0; i--) {
								String key = removeList.remove(i);
								if (null != key) {
									synchronized (sessionMap) {
										sessionMap.remove(key);
									}
								}
							}
						}
					}
				}
			});
			DaemonThread.setDaemon(true);
			DaemonThread.start();
		}
	}

	private final static Map<String, Session> sessionMap = Collections
			.synchronizedMap(new HashMap<String, Session>());// new Coll<String,
																// Session>();
	private final String sessionID;
	// private String requestIP;
	private String remortIP;
	private UserBean user;
	private Object httpServletRequest;
	private long lastHaveTime;
	private final Map<String, Object> data = new HashMap<String, Object>();

	private Session() {
		// sessionID = UUID.randomUUID().toString();
		// lastHaveTime = System.currentTimeMillis();
		// initThread();
		this(UUID.randomUUID().toString());
	}

	private Session(String sessionID) {
		if (sessionMap.size() >= maxSessionNumber) {
			throw new SystemBusyException("超过session并发上线");
		}
		synchronized (sessionMap) {
			if (sessionMap.containsKey(sessionID)) {
				throw new SessionRepeatStructureException(sessionID);
			}
			sessionMap.put(sessionID, this);
		}
		this.sessionID = sessionID;
		lastHaveTime = System.currentTimeMillis();
		initThread();
	}

	// javax.servlet.http.HttpServletRequest
	public static Session newSession(Object httpServletRequest, String requestIP)
			throws LoginException {
		try {
			Class<?> request = Class.forName(
					"javax.servlet.http.HttpServletRequest", true, Thread
							.currentThread().getContextClassLoader());
			if (httpServletRequest.getClass().isAssignableFrom(request)) {
				throw new LoginException(
						"javax.servlet.http.HttpServletRequest参数传入错误");
			}
		} catch (ClassNotFoundException e) {
			throw new LoginException(
					"javax.servlet.http.HttpServletRequest参数传入错误", e);
		}
		Session session = new Session();
		session.httpServletRequest = httpServletRequest;
		session.remortIP = requestIP;
		// return putSession(session);
		return session;
	}

	// javax.servlet.http.HttpServletRequest
	public static Session newSession(Object httpServletRequest,
			String requestIP, String sessionID) throws LoginException {
		try {
			Class<?> request = Class.forName(
					"javax.servlet.http.HttpServletRequest", true, Thread
							.currentThread().getContextClassLoader());
			if (httpServletRequest.getClass().isAssignableFrom(request)) {
				throw new LoginException(
						"javax.servlet.http.HttpServletRequest参数传入错误");
			}
		} catch (ClassNotFoundException e) {
			throw new LoginException(
					"javax.servlet.http.HttpServletRequest参数传入错误", e);
		}
		Session session = new Session(sessionID);
		session.httpServletRequest = httpServletRequest;
		session.remortIP = requestIP;
		// return putSession(session);
		return session;
	}

	public static Session newSession(String requestIP) throws LoginException {
		Session session = new Session();
		session.httpServletRequest = null;
		session.remortIP = requestIP;
		// return putSession(session);
		return session;
	}

	public static Session newSession() throws LoginException {
		Session session = new Session();
		session.httpServletRequest = null;
		session.remortIP = null;
		// return putSession(session);
		return session;
	}

	public static Session getSession(String sessionID) throws LoginException {
		if(null != dsession){
			return dsession;
		}
		if (null == sessionID || "".equals(sessionID.trim())) {
			return null;
		}
		Session session = null;
		synchronized (sessionMap) {
			if (null != sessionID)
				session = sessionMap.get(sessionID);
		}
		if (null == session) {
			StringBuffer s = new StringBuffer("(当前session个数："
					+ sessionMap.size() + ")");
			s.append(" \n ");
			for (Session se : sessionMap.values()) {
				s.append(se.getSessionID());
				s.append(" ");
			}
			System.out.println(s.toString());
			throw new LoginException("您的登录信息已过期，请重新登录！" + s.toString());
		}
		session.lastHaveTime = System.currentTimeMillis();
		return session;
	}

	public static Session vali(String sessionID) throws LoginException {
		return getSession(sessionID);
	}

	public static Session loginOut(String sessionID) {
		synchronized (sessionMap) {
			return sessionMap.remove(sessionID);
		}
	}

	//
	public static void setThread(Session session) {
		local.set(session);
	}

	public static void removeThread() {
		local.remove();
	}

	public static Session getThread() {
		return local.get();
	}

	//
	// private static Session putSession(Session session) {
	// sessionMap.put(session.sessionID, session);
	// return session;
	// }

	//
	public String getRemortIP() {
		return remortIP;
	}

	public void setRemortIP(String remortIP) {
		this.remortIP = remortIP;
	}

	public UserBean getUser() {
		return user;
	}

	public void setUser(UserBean user) {
		this.user = user;
	}

	public Object getHttpServletRequest() {
		return httpServletRequest;
	}

	public void setHttpServletRequest(Object httpServletRequest) {
		this.httpServletRequest = httpServletRequest;
	}

	public String getSessionID() {
		return sessionID;
	}

	public Session put(String key, Object value) {
		data.put(key, value);
		return this;
	}

	public Object get(String key) {
		return data.get(key);
	}
}