web项目通过Session监听器控制在线人数以及同一用户异地登陆限制

对于项目中要求控制同时在线人数的需求，可以通过Session监听器来实现。

Session监听器类：

public class UserLoginListener implements HttpSessionAttributeListener
{
@Override
public void attributeAdded(HttpSessionBindingEvent se)
{
String username = se.getName();
String sessionId = se.getSession().getId();
if (username == BaseAction.SESSION_USER)
{
new OnlineUserMap().removeUser(sessionId);
User userInfo = (User) se.getSession().getAttribute(username);
userInfo.setSessionId(sessionId);
new OnlineUserMap().addOnlineUser(userInfo.getUserId(), userInfo);
}

}

@Override
public void attributeRemoved(HttpSessionBindingEvent se)
{
String username = se.getName();
String sessionId = se.getSession().getId();
if (username == BaseAction.SESSION_USER)
{
new OnlineUserMap().removeUser(sessionId);
}
}

@Override
public void attributeReplaced(HttpSessionBindingEvent se)
{
String username = se.getName();
String sessionId = se.getSession().getId();
if (username == BaseAction.SESSION_USER)
{
new OnlineUserMap().removeUser(sessionId);
User userInfo = (User) se.getSession().getAttribute(username);
userInfo.setSessionId(sessionId);
new OnlineUserMap().addOnlineUser(userInfo.getUserId(), userInfo);
}
}

}

Session监听器实现HttpSessionAttributeListener接口，需要实现该接口的三个方法：attributeAdded、attributeRemoved和attributeReplaced，其中：

attributeAdded        //在session中添加对象时触发此操作 笼统的说就是调用setAttribute这个方法时候会触发的

attributeRemoved   //修改、删除session中添加对象时触发此操作  笼统的说就是调用 removeAttribute这个方法时候会触发的

attributeReplaced   //在Session属性被重新设置时

Action基类的BaseAction类：

public class BaseAction extends ActionSupport
{
private static final long serialVersionUID = -5102862846807662318L;
public static final String INFO = "info";
public static final String ERROR = "error";
public static final String SUCCESS = "success";
public static final String HOMEPAGE = "homepage";

private static final ResultEntity SUCCESS_ENTITY = new ResultEntity();

public static final String SESSION_USER = "USER_INFOMATION";

public static final String SESSION_USERNAME = "CS_SESSION_USERNAME";

private static JsonConfig jsonConfig = new JsonConfig();

/**
* 语言Map对象<br>
*/
protected static Map<String, Locale> localMap = new HashMap<String, Locale>();
/**
* 初始化语言Map的key→value数据
*/

static
{
jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor());
localMap.put("en", Locale.ENGLISH);
localMap.put("zh", Locale.SIMPLIFIED_CHINESE);
}

/* 向页面传递error信息 */
public String errormessage;
/* 向页面传递info信息 */
public String infomessage;
/* 向页面传递error信息，返回URL */
public String backURL;

/* 显示模式: 0为列表,1为缩略图,共享session中保存 */
private int mode = 0;

/* 排列顺序： 0为倒序,1为顺序 */
private int sort = 0;

/* 排列字段： 默认为时间 */
private int sorttype = 0;

private String requestFrom;

/**
* 当启用共享session的时候，根据sessionID获得共享的session，否则获取tomcat默认的session
*
* @param sessionid
* @return
* @throws Exception
*/
public HttpSession findSession()
{
return ServletActionContext.getRequest().getSession();
}

/**
* 获得request对象
*
* @return
*/
public HttpServletRequest getRequest()
{
return ServletActionContext.getRequest();
}

/**
* 获得response对象
*
* @return
*/
public HttpServletResponse getResponse()
{
return ServletActionContext.getResponse();
}

/**
* 获得servlet上下文
*
* @return
*/
public ServletContext getServletContext()
{
return ServletActionContext.getServletContext();
}

protected void rsaResponse(ResultEntity resultEntity)
{
toJson(resultEntity);
}

/**
* 将对象以json方式返回
* @param obj 需要转换为json字符串的对象
*/
protected void toJson(Object obj)
{
try
{
// 如果obj为CsResponse类或其子类，则判断retMessage是否为空，为空则根据retCode设置retMessage
if (obj instanceof ResultEntity)
{
ResultEntity resultEntity = (ResultEntity) obj;
if (StringUtils.isEmpty(resultEntity.getMesg()))
{
resultEntity.setMesg(getText(resultEntity.getResult()));
}
}

IOUtils.write(JSONObject.fromObject(obj, jsonConfig).toString(), getJsonResponse().getWriter());
}
catch (IOException e)
{
LoggerUtil.logger.error(obj + " convert to json failed.", e);
}
}

protected void successResponse()
{
toJson(SUCCESS_ENTITY);
}

/**
* 获取json返回方式的Response
* @return response
*/
protected HttpServletResponse getJsonResponse()
{
HttpServletResponse response = getResponse();
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json;charset=UTF-8");
return response;
}

protected String getRequestIp()
{
return RequestUtil.getIpAddr(getRequest());
}

protected SessionUser getSessionUser()
{
return (SessionUser) findSession().getAttribute(SESSION_USER);
}

protected void cacheSessionUser(SessionUser user)
{
HttpSession session = findSession();
session.setAttribute(SESSION_USER, user);
session.setAttribute(SESSION_USERNAME, user.getUsername());
}

public int getMode()
{
return mode;
}

public void setMode(int mode)
{
this.mode = mode;
}

public int getSort()
{
return sort;
}

public void setSort(int sort)
{
this.sort = sort;
}

public int getSorttype()
{
return sorttype;
}

public void setSorttype(int sorttype)
{
this.sorttype = sorttype;
}

public String getErrormessage()
{
return errormessage;
}

public void setErrormessage(String errormessage)
{
this.errormessage = errormessage;
}

public String getInfomessage()
{
return infomessage;
}

public void setInfomessage(String infomessage)
{
this.infomessage = infomessage;
}

public String getBackURL()
{
return backURL;
}

public void setBackURL(String backURL)
{
this.backURL = backURL;
}

public void setRequestFrom(String requestFrom)
{
this.requestFrom = requestFrom;
}

public String getRequestFrom(String defaultFrom)
{
if (StringUtils.isBlank(requestFrom))
{
return defaultFrom;
}

return requestFrom;
}

public String getPostBody()
{
String body = null;
try
{
body = IOUtils.toString(getRequest().getInputStream());
}
catch (IOException e)
{
e.printStackTrace();
}
if (StringUtils.isBlank(body))
{
throw new CsException(ReturnCode.PARAM_ERROR);
}
return body;
}

protected void resetLanguage()
{
String language = ServletActionContext.getRequest().getParameter("language");

if (StringUtils.isBlank(language))
{
return;
}

if (localMap.containsKey(language))
{
ServletActionContext.getContext().setLocale(localMap.get(language));
}
else
{
ServletActionContext.getContext().setLocale(new Locale(language));
}
}
}

Session监听器web.xml文件配置:

<listener>
<listener-class>com.zte.init.UserLoginListener</listener-class>
</listener>

缓存在线用户数据，在线用户集合类：

public class OnlineUserMap
{
public static Map<Integer, User> onlineuser = new HashMap<Integer, User>();

/**
* 得到在线用户
* @return
*/
public static Map<Integer, User> getOnlineuser()
{
return onlineuser;
}

/**
* 添加在线用户
* @param sessionId
* @param userName
* @return
*/
public void addOnlineUser(Integer userId, User user)
{
onlineuser.put(userId, user);
}

/**
* 移除用户
* @param userName
*/
public void removeUser(String sessionId)
{
for (Integer userId : onlineuser.keySet())
{
if (onlineuser.get(userId).getSessionId().equals(sessionId))
{
onlineuser.remove(userId);
break;
}
}
}

}

在用户登录的流程中做如下操作限制登录人数：

int limitUser = 30;
new OnlineUserMap();
int userNumber = OnlineUserMap.onlineuser.keySet().size();
if (userNumber >= limitUser){
LoggerUtil.logger.error("Current online population is " + OnlineUserMap.onlineuser.keySet().size()
+ ", limit population " + limitUser);
throw new CsException(ReturnCode.ONLINE_USER_LIMIT);
}

限制同一个用户多地登录：

HttpServletRequest session = ServletActionContext.getRequest();
String sessionId = session.getSession().getId();
new OnlineUserMap();
//当前登陆的Session/User
User loginuserinfo = OnlineUserMap.onlineuser.get(user.getUserId());
if (loginuserinfo != null)
{
if (loginuserinfo.getSessionId() != null)
{
if (!loginuserinfo.getSessionId().equals(sessionId))
{
throw new CsException(ReturnCode.USER_LOGGED);
}
}
}

从HttpservletRequest中获取ip地址：

/**
* 从HttpservletRequest中获取ip地址
* @param request 请求对象
* @return
*/
public static String getIpAddr(HttpServletRequest request)
{
String ipAddress = request.getHeader("x-forwarded-for");
if (StringUtils.isBlank(ipAddress) || "unknown".equalsIgnoreCase(ipAddress))
{
ipAddress = request.getHeader("Proxy-Client-IP");
}
if (StringUtils.isBlank(ipAddress) || "unknown".equalsIgnoreCase(ipAddress))
{
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}

if (StringUtils.isBlank(ipAddress) || "unknown".equalsIgnoreCase(ipAddress))
{
ipAddress = request.getHeader("x-request-ip");
}
if (StringUtils.isBlank(ipAddress) || "unknown".equalsIgnoreCase(ipAddress))
{
ipAddress = request.getRemoteAddr();
if (ipAddress.equals("127.0.0.1"))
{
// 根据网卡取本机配置的IP
InetAddress inet = null;
try
{
inet = InetAddress.getLocalHost();
ipAddress = inet.getHostAddress();
}
catch (UnknownHostException e)
{
e.printStackTrace();
}
}
}

// 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
if (ipAddress != null && ipAddress.length() > 15)
{
if (ipAddress.indexOf(",") > 0)
{
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
}
}
return ipAddress;
}