豆丁微信公众号
君，已阅读到文档的结尾了呢~~
session_3-VC-项目筛选与评估（可编辑）,vc编辑框换行,session,php session,session 生命周期,session start,ulala session,session.invalidate,thinkphp session,sessionfactory
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
session_3-VC-项目筛选与评估（可编辑）
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='http://www.docin.com/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口excel筛选后为什么平均值求的不对？_百度知道
excel筛选后为什么平均值求的不对？
并没有被删除。而你用=AVERAGE(E509.72了。外话，1楼“思雪遥遥”也许理解错了。你试着下拉筛选▲选（全部）看看对公式计算有没有影响:E1546)的引用数据区域里面包含了很多被隐藏的数据，故所得出的平均值肯定不是你想要的88，复制显示的数据到另一个工作表再进行平均计算。必要时看你的附图，用自动筛选，只是把不符合条件的行给予隐藏起来而已
采纳率：72%
为您推荐：
其他类似问题
您可能关注的内容
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。1223人阅读
web学习（8）
session（3）
Session，又被称为会话。是指有始有终的一系列动作/消息。
用户请求访问某个网站域名时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象，存放在服务端，此对象的唯一标识放入cookie中。这样，当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。但是session对象是有生命周期的，当会话过期或被放弃后，服务器将终止该会话。
Session 对象存储特定用户会话所需的属性及配置信息。最常见的一个用法就是存储用户的首选项。例如，用户登录之后的登录信息，就可以将该信息存储在 Session 对象中。
在开发工程中，常用到的是javax.servlet.http.HttpSession。
cookie与session：
我们都知道，HTTP协议本身是无状态的，客户端只需要简单的向服务器发送请求，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的。
但是在后来发展应用中，需要客户端和服务端保持状态。这样cookie就产生了，其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。cookie就是在客户端保持状态，session是在服务端保持状态，但是又是借助客户端的，所以在使用过程中，session的唯一标识常保持在cookie中的。一般取名JSESSIONID=唯一标识（可以动过UUID方式产生）。考虑到实际情况中，cookie在客户端被禁用了，这时候可以直接通过请求参数方式传入。
因为session的唯一标识在cookie当中，跟随着cookie的生命周期。一般cookie的默认生命周期是浏览器关闭结束，所以session在浏览器关闭时也当做结束。但是，只要服务端session还在，通过相同的session唯一标示依然可以保持状态。
前面说过，session保持在服务端，当大量请求时，session就会占用大量内存，所以在会给session设置个过期时间，释放空间。
httpsession:
httpSession是java提供的一个接口。提供了一些对session的操作方法：
public String getId(); //获取session的唯一标识
public long getLastAccessedTime(); //获取最后的请求过来的时间（毫秒）
public ServletContext getServletContext();//获取session所属的上下文
public void setMaxInactiveInterval(int interval);//设置有效期（秒）
public Object getAttribute(String name); //获取session中存放的对象
public Enumeration getAttributeNames(); //获取所有存放对象
public void setAttribute(String name, Object value); //存放对象到session中。如果放入的对象为null，效果跟removeAttribute()一致。
public void removeAttribute(String name);//移出session中的对象
public void invalidate(); //无效session
public boolean isNew(); //判断客户端是不是支持session的。如果客户端不支持cookie，每次请求都会创建个新的session。
一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用。
文章开头，当请求过来时，没有就创建。其实严格的来说，并非这样的，实际上是调用了HttpServletRequest中的public HttpSession getSession(boolean create);实现时才获取出来session。
我们先来看下源码中这个方法的说明：
*返回此请求的关联当前httpSession,如果没有，当create设置为true时，就会创建个新的session；
如果create为false，同时请求request没有有效的httpSession，则就会返回null；*
我们可以这样测试：创建两个页面，一个是jsp，一个是html。jsp本质上就是一个servlet，参与服务交互，SP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。html是个静态页面，与服务器没有啥交互。
请求后，可以看出返回response中没有session。
请求后，可以看出有session了。
我们也是可以控制不创建session。在webcome.jsp页面上添加：
&%@ page session="false" %& 设置session为false时，关闭session。再次请求可以看到，没有看到session了。
我们可以深入源码中探查：
新创建个jsp页面error.jsp，这个session默认是打开的。请求welcome.jsp和error.jsp页面后，在tomcat中查看所生成的对应servlet文件。生成的servlet文件在tomcat下面的 work\Catalina\localhost\web_01\org\apache\jsp文件夹中。
首先看到error.jsp生成的servlet文件error_jsp.java:
package org.apache.jsp
import javax.servlet.*
import javax.servlet.http.*
import javax.servlet.jsp.*
public final class error_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory()
//其他代码省略
**********
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
final javax.servlet.jsp.PageContext pageContext
//注意：这里是HttpSession
javax.servlet.http.HttpSession session = null
final javax.servlet.ServletContext application
final javax.servlet.ServletConfig config
javax.servlet.jsp.JspWriter out = null
final java.lang.Object page = this
javax.servlet.jsp.JspWriter _jspx_out = null
javax.servlet.jsp.PageContext _jspx_page_context = null
response.setContentType("text/ charset=UTF-8")
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true)
_jspx_page_context = pageContext
application = pageContext.getServletContext()
config = pageContext.getServletConfig()
//从页面上下文中获取session
session = pageContext.getSession()
out = pageContext.getOut()
_jspx_out = out
//省略页面渲染代码
} catch (java.lang.Throwable t) {
//省略异常处理代码
} finally {
_jspxFactory.releasePageContext(_jspx_page_context)
代码中可以看到HttpSession是从PageContext中获取。注意，这里的pageContext所属package为javax.servlet.jsp下面，此所属jar在tomcat本身的lib文件jsp-api.jar中。
这个pageContext是个抽象类，代码中pageContext = _jspxFactory.getPageContext(this, request, response, null, true, 8192, true);是个抽象类赋上具体的实现，再通过代码：
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory();定位到JspFactory类。进入看下源代码：
//***********
先省略，后续补上。
//*********
当session关闭时，web.jsp的servlet文件中就没有看到HttpSession的相关内容。
当session被调用invalidate()方法时，或过期时就会终止。
分布式环境下的session：
因为session是存在服务器上，当应用集群时就成为一个问题。请求同一个网站，前一个请求到A服务器上，获取session，保持在A服务器上，但是下一个请求可能会分配到B服务器上，此时就识别不了session了。
一般来说有几种解决方法：
1：服务器直接同步session：集群中的服务器相互同步session，但是问题不少。首先实时性不好保证，其次同步的次数随着服务器的数量二指数级别增加，所以在实际中很少用到。
2：对请求进行筛选处理：判断请求的IP，给分配到固定的服务器上，达到同一个IP请求始终访问同一个服务器。但是依然问题不少：请求IP解析匹配的开销不少；如果某个服务器挂掉了，会导致访问这个请求失败；削弱了负载均衡的能力，会导致某些服务器负载很高，而某些却空闲；动态增减服务器需要修改ip的分配，这回增减很多难度。
3：使用缓存：让集群的session都放入同一个缓存中，与服务器脱离依赖。现实中常用这样的方式。不过这样缓存就会成为一个瓶颈，不过可以考虑对缓存进行集群来解决。
缓存session实例：
首先配置redis相关：
&org.springframework.data&
&spring-data-redis&
&1.7.1.RELEASE&
&redis.clients&
xml配置（使用的是spring-context-4.2.xsd）：
location="config/redis.properties"/&
id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"&
name="maxTotal" value="50" /&
name="maxIdle" value="10" /&
name="minIdle" value="2" /&
name="maxWaitMillis" value="12000" /&
name="blockWhenExhausted" value="true" /&
name="testOnBorrow" value="true" /&
name="testOnReturn" value="true" /&
name="testWhileIdle" value="true" /&
name="timeBetweenEvictionRunsMillis" value="1800000" /&
name="numTestsPerEvictionRun" value="5" /&
id="redisFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"&
name="poolConfig" ref="jedisPoolConfig"&&
name="hostName" value="${redis.host}"&&
name="port" value="${redis.port}"&&
name="timeout" value="${redis.timeout}"&&
id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"&
name="connectionFactory" ref="redisFactory" /&
name="keySerializer"&
class="org.springframework.data.redis.serializer.StringRedisSerializer" /&
自定义session类：
import java.io.S
import java.util.HashM
import java.util.M
import java.util.S
import com.zcl.session.util.SessionM
* 自定义Session类
public class SystemSession implements Serializable {
private static final long serialVersionUID = 0390228L;
* session数据存储map
private Map&String,Object& sessionData = new HashMap&String,Object&();
* sessionId
session标识
private String sessionId = null;
public String getSessionId() {
return sessionId;
public void setSessionId(String sessionId) {
this.sessionId = sessionId;
public Object getAttribute(String name){
Object value = sessionData.get(name);
public void setAttribute(String name,Object value){
sessionData.put(name, value);
SessionManager.updateSession(this.sessionId, this);
public void removeAttribute(String name){
sessionData.remove(name);
SessionManager.updateSession(this.sessionId, this);
public void removeAllAttribute(){
sessionData.clear();
SessionManager.updateSession(this.sessionId, this);
public void disable(){
SessionManager.deleteSession(this.sessionId);
public boolean hasAttributeName(String name){
return sessionData.containsKey(name);
public Set&String& getAttributeNames(){
return sessionData.keySet();
public Map&String, Object& getSessionData() {
return sessionD
public void setSessionData(Map&String, Object& sessionData) {
this.sessionData = sessionD
session管理类:
import java.util.UUID;
import java.util.concurrent.TimeU
import javax.servlet.http.C
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import org.apache.commons.lang3.StringU
import org.apache.log4j.L
import org.springframework.data.redis.core.RedisT
import com.zcl.constants.C
import com.zcl.session.bean.SystemS
import com.zcl.util.CookieU
import com.zcl.util.SpringU
import com.zcl.util.UUIDU
* 自定义Session的工具类
public class SessionManager {
private static Logger logger = Logger.getLogger(SessionManager.class);
* 从request中获取sessionKey的值
*: getSessionIdFromRequest
* sessionKey
public static String getSessionIdFromRequest(HttpServletRequest request, String sessionKey) {
String sessionId = null;
if (StringUtils.isBlank(sessionId)) {
sessionId = request.getParameter(sessionKey);
if (StringUtils.isBlank(sessionId)) {
sessionId = request.getHeader(sessionKey);
Cookie cookie = CookieUtil.getCookieByName(request, sessionKey);
if (cookie != null && StringUtils.isBlank(sessionId)) {
sessionId = cookie.getValue();
if (StringUtils.isBlank(sessionId))
sessionId = (String) request.getAttribute(sessionKey + "_attr");
return sessionId;
* 获取一个session
* response
public static SystemSession createSession(String sessionKey, String sessionId, HttpServletRequest request,
HttpServletResponse response) {
if (StringUtils.isBlank(sessionKey))
return null;
if (StringUtils.isBlank(sessionId))
sessionId = UUIDUtils.generateSessionKey();
response.setHeader("P3P","CP='CP=CAO PSA OUR'");
CookieUtil.addCookie(request, response, sessionKey, sessionId, null);
request.setAttribute(sessionKey+"_attr", sessionId);
SystemSession session = new SystemSession();
session.setSessionId(sessionId);
RedisTemplate&String, SystemSession& redisTemplate = getRedisTemplate();
redisTemplate.opsForValue().set(sessionId, session);
redisTemplate.expire(sessionId, Constants.APP_SESSION_TIMEOUT, TimeUnit.SECONDS);
* 根据sessionId从redis中获取对应session信息
*: getSession
* sessionId
public static SystemSession getSessionFromRedis(String sessionId) {
SystemSession session = null;
if (StringUtils.isNotBlank(sessionId)) {
RedisTemplate&String, SystemSession& redisTemplate = getRedisTemplate();
session = (SystemSession) redisTemplate.opsForValue().get(sessionId);
* 通过uuid生成sessionID
public static String generateSessionKey() {
String sessionKey = UUID.randomUUID().toString();
return sessionKey.replace("-", "");
* 更新session数据内容
* sessionKey
public static void updateSession(String sessionKey, SystemSession session) {
setSessionTimeout(sessionKey, session);
* 删除session,使其失效
* sessionKey
public static void deleteSession(String sessionKey) {
RedisTemplate&String, SystemSession& redisTemplate = getRedisTemplate();
redisTemplate.delete(sessionKey);
public static RedisTemplate&String, SystemSession& getRedisTemplate() {
@SuppressWarnings("unchecked")
RedisTemplate&String, SystemSession& redisTemplate = (RedisTemplate&String, SystemSession&) SpringUtils
.getBeanByName("redisTemplate");
return redisT
* 设置Session超时时间
private static void setSessionTimeout(String sessionKey, SystemSession session) {
long sessionTimeout = Constants.APP_SESSION_TIMEOUT;
RedisTemplate&String, SystemSession& redisTemplate = getRedisTemplate();
redisTemplate.opsForValue().set(sessionKey, session);
redisTemplate.expire(sessionKey, sessionTimeout, TimeUnit.SECONDS);
在管理方法中获取redisTemplate对象是通过SpringUtils的公共方法
SpringUtils方法：
import org.springframework.web.context.ContextL
import org.springframework.web.context.WebApplicationC
public class SpringUtils {
private static WebApplicationContext webAppContext = ContextLoader.getCurrentWebApplicationContext();
public static Object getBeanByName(String beanName) {
return webAppContext.getBean(beanName);
public static Object getBeanByClass(Class&?& className) {
return webAppContext.getBean(className);
以上基本上搭建好了一个自定义的session。然后在模拟session的生产和使用情况。通过Filter或者Interceptor的方式：
SessionFilter方法：
import java.io.IOE
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import org.apache.commons.lang3.StringU
import com.zcl.constants.C
import com.zcl.session.bean.SystemS
import com.zcl.session.util.SessionM
public class SessionFilter implements Filter {
private boolean openFlag = false;
public void init(FilterConfig filterConfig) throws ServletException {
String openFlagStr = filterConfig.getInitParameter("openFlag");
openFlag = StringUtils.equals(openFlagStr, "true");
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
if(openFlag) {
SystemSession session = null;
String sessionId = SessionManager.getSessionIdFromRequest((HttpServletRequest)request, Constants.SESSION_KEY);
if(StringUtils.isNotBlank(sessionId)) {
session = SessionManager.getSessionFromRedis(sessionId);
if(session == null) {
session = SessionManager.createSession(Constants.SESSION_KEY, sessionId,
(HttpServletRequest)request, (HttpServletResponse)response);
request.setAttribute(Constants.SESSION_KEY, session);
chain.doFilter(request, response);
public void destroy() {
然后在web.xml中配置：
&filter-name&sessionFilter&/filter-name&
&filter-class&com.zcl.filter.SessionFilter&/filter-class&
&init-param&
&param-name&openFlag&/param-name&
&param-value&true&/param-value&
&/init-param&
&filter-mapping&
&filter-name&sessionFilter&/filter-name&
&url-pattern&*.htm&/url-pattern&
&/filter-mapping&
此个filter应放在最先的位置。
在使用的地方，直接从httpServletRequest中获取即可
public SystemSession getSystemSession(HttpServletRequest request) {
return (SystemSession)request.getAttribute(Constants.SESSION_KEY_USER);
上门是使用的filter过滤器方式，下面修改成拦截器Interceptor方式，同时加上登录之后才能访问的地址过滤处理：
SecurityInterceptor
import java.util.L
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import org.apache.commons.lang3.StringU
import org.springframework.web.bind.annotation.RequestM
import org.springframework.web.servlet.ModelAndV
import org.springframework.web.servlet.handler.HandlerInterceptorA
import com.zcl.constants.C
import com.zcl.session.bean.SystemS
import com.zcl.session.util.SessionM
import com.zcl.util.CookieU
import com.zcl.util.JSE
import com.zcl.util.PropertyU
* 判断用户权限，未登录用户跳转到登录页面
*: SecurityInterceptor
* May 5, :34 PM
public class SecurityInterceptor extends HandlerInterceptorAdapter {
private List&String& includedU
private List&String& excludedU
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
super.postHandle(request, response, handler, modelAndView);
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
request.setAttribute("mid", PropertyUtils.getProperty("MLTrackerz_MID"));
String requestUri = request.getRequestURI();
SystemSession session = null;
String sessionId = SessionManager.getSessionIdFromRequest(request, Constants.SESSION_KEY);
if(sessionId != null){
session = SessionManager.getSessionFromRedis(sessionId);
if (session == null) {
session = SessionManager.createSession(Constants.SESSION_KEY, sessionId, request, response);
request.setAttribute(Constants.SESSION_KEY, session);
boolean mustLogin = false;
if (includedUrls != null && includedUrls.size() & 0) {
for (String url : includedUrls) {
if (requestUri.matches(url)) {
mustLogin = true;
if (!mustLogin) {
return true;
} else if (excludedUrls != null && excludedUrls.size() & 0) {
for (String url : excludedUrls) {
if (requestUri.matches(url)) {
return true;
if (session == null
|| session.getAttribute(Constants.LOGIN_USER_KEY) == null) {
StringBuffer beforeLoginPage = request.getRequestURL();
if(StringUtils.isNotBlank(request.getQueryString())){
beforeLoginPage.append("?").append(request.getQueryString());
if (request.getMethod().equalsIgnoreCase(
RequestMethod.GET.toString())
&& beforeLoginPage.toString().indexOf("logout") == -1) {
CookieUtil.addCookie(request, response,
Constants.BEFORE_PAGE, JSEscape.escape(beforeLoginPage.toString()), null);
response.sendRedirect(request.getContextPath() + "/tologin");
return false;
return super.preHandle(request, response, handler);
public void setExcludedUrls(List&String& excludedUrls) {
this.excludedUrls = excludedU
public void setIncludedUrls(List&String& includedUrls) {
this.includedUrls = includedU
这时候context.xml中的配置要变成interceptor的方式了：
id="securityInterceptor" class="com.zcl.interceptor.SecurityInterceptor"&
name="excludedUrls"&
&/tologin.htm&
&/loginout.htm&
name="includedUrls"&
&/myaddress.htm&
&/mycredit.htm&
path="/*"/&
path="/resource/**"/&
bean="securityInterceptor"/&
然后我们在controller中使用：
@RequestMapping(value={"/","index.htm"})
public ModelAndView index(HttpServletRequest request, ModelAndView mav) {
SystemSession session = (SystemSession)request.getAttribute(Constants.SESSION_KEY)
String userName = (String) session.getAttribute("userName")
if(StringUtils.isBlank(userName)) {
System.out.println("setUserName")
session.setAttribute("userName", "zcl")
System.out.println("getUserName:" + userName)
mav.setViewName("index")
return mav
结果符合预期：
第一次请求时userName为NULL；第二次时为”zcl”。表示session唯一，同时放入session中的值也是跟随着用户的。
以上是我们单独构建的session处理，其实spring也提供了相关的封装，spring-session中已经封装了类似的处理。
springSession
观察上面我们的session处理过程，可以看出有两部分重点：
一是session怎样定义？session是个怎样的结果。
二是session怎样存放？因为在分布式环境下，session要采取啥方式存放；
三是session怎样与Request关联？因为每次请求中，都涉及到session的。
在上面的session构建中，通过redis方式存放session；通过cookie/header/参数方式与request/response关联。
知道了原理后，我们查看sping-session的源码，可以看出，实现的原理是一致的，只不过它提供了更好更多的扩展。
具体分析可以查看后面关于springSession学习的文章。}