<filter>
<filter-name>Session Timeout Filter</filter-name>
<filter-class>com.vstsoft.common.filter.SessionTimeoutFilter</filter-class>
<init-param>
<param-name>redirectURL</param-name>
<param-value>/loginOut.jsp</param-value>
</init-param>
<init-param>
<param-name>exceptFiles</param-name>
<param-value>
/#/login.jsp#/loginOut.jsp
</param-value>
</init-param>
<init-param>
<param-name>enable</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>Session Timeout Filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

 <session-config>
<session-timeout>30</session-timeout>
</session-config> 

 


把这段放到web.xml中就可以了


详细内容查看Session Timeout Filter

在Web应用中，会用到大量的Ajax请求，在Ajax请求中存在的一个问题就是如何判断session超时，在网上找到的一个java中处理此问题方法：

1.java中：


public boolean preHandle(HttpServletRequest request,HttpServletResponse response, Object handler) throws Exception

{

         if (request.getSession().getAttribute("user") == null)//判断session里是否有用户信息

            {

             if (request.getHeader("x-requested-with") != null&& request.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest"))

                   //如果是ajax请求响应头会有，x-requested-with；

             {

                 response.setHeader("sessionstatus", "timeout");//在响应头设置session状态

                 return false;

             }  

         }

         return true;

}

//全局的ajax访问，处理ajax清求时sesion超时

     $.ajaxSetup({ 

             contentType:"application/x-www-form-urlencoded;charset=utf-8", 

             complete:function(XMLHttpRequest,textStatus){ 

                     var sessionstatus=XMLHttpRequest.getResponseHeader("sessionstatus"); //通过XMLHttpRequest取得响应头，sessionstatus，

                     if(sessionstatus=="timeout"){  //如果超时就处理 ，指定要跳转的页面

                                         window.location.replace("${path}/common/login.do"); 

                                 } 

                      } 

             } 

      });



2.由于我的项目是Zend Framework，下面贴上zf中的解决方法

 首先要在Controller_Plugin中定义，添加自定义的header: 


<?php
class Lby_Controller_Plugin_Ajax extends Zend_Controller_Plugin_Abstract
{
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
             if ($this->getRequest()->isXmlHttpRequest()) {     //首先判断是否是Ajax请求
                 
                 $user=new Zend_Session_Namespace("user");       //获取session
                 if (!isset($user->user)) {                      //不存在，说明超时
                     $this->getResponse()->setHeader("sessionStatus", "timeout");   
                 }else{                                          //存在
                     $this->getResponse()->setHeader("sessionStatus", "timeall"); 
                  }
              }
    }
}



 然后在js中：


$(document).ready(function(){
   $.ajaxSetup({
        complete:function(XMLHttpRequest){
           var sessionstatus=XMLHttpRequest.getResponseHeader("sessionstatus");
           if(sessionstatus=="timeout"){
             window.location.replace("${path}/user/user/login");  //跳转到登录界面，待改进
           }
        }
    });
});

--转自http://www.iteye.com/problems/70335
jquery ajax方法调用在session超时以后如何跳转到登录页面？ 
session超时以后虽然被过滤器过滤到了，但是并不会跳转到登录页面请求具体的解决方法。 


我参考了这篇文章，但是我调用ajaxStart不起作用。 


http://www.blogjava.net/vickzhu/archive/2009/06/05/280223.html 


ext jquery 用户访问超时(ext session过期) 


解决两种情况下的用户访问超时。 

a）普通http请求的session超时。 

b）异步http请求的session超时，使用ext后大部分的界面刷新都是异步的ajax请求。 


不管是那种类型的http请求总是可以由一个过滤器来捕捉。 

分类：普通http请求的header参数中没有x-requested-with:XMLHttpRequest头信息，而异步的有。 

其实对于常见的ajax框架，header中还有标示自己身份的header信息。 


对于普通的http请求，发现session超时后直接重定向到一个超时页面，显示访问超时。 

对于异步http请求，发现session超时后则向请求的response中写入特定的超时头信息，客户端ajax对象检测 

头信息，发现有超时状态标志后调用显示超时信息的javascript方法，提示用户访问超时。 


服务器端session超时后在过滤器中为response添加新的头信息，标记该请求超时： 


if(r.getHeader("x-requested-with")!=null 

&& r.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")){ 

response.setHeader("sessionstatus","timeout"); 

} 

使用Ext.Ajaxt对象完成异步请求的交互，Ext.Ajax是单实例对象（非常重要，全局单一Ext.Ajax实例！）。 

注册Ext.Ajax的requestcomplete事件，每个ajax请求成功后首先响应该事件。在该事件的回调函数里面判断 

访问请求是否超时。使用Ext.Ajax对象的好处是，只需要引入一个包含了几行超时处理代码的js文件，就可以 

为当前应用增加超时处理功能，原有代码不需要做任何修改。 



使用Ext.Ajaxt对象完成异步请求交互，假如checkUserSessionStatus是你的回调方法，每个页面引用： 


Ext.Ajax.on('requestcomplete',checkUserSessionStatus, this); 

function checkUserSessionStatus(conn,response,options){ 

//Ext重新封装了response对象 

if(typeof response.getResponseHeader.sessionstatus != 'undefined'){ 

//发现请求超时，退出处理代码... 

} 

} 

可以利用的几个特性：a）所有的ajax请求均带有x-requested-with:XMLHttpRequest头信息b）Ext.Ajax是单实例对象（非常重要，全局单一Ext.Ajax实例！）c）注册Ext.Ajax的requestcomplete事件，每个ajax请求成功后首先响应该事件（概念类似spring的aop拦截）。 

jquery提供了几个全局事件可以用来处理session过期请求，如当ajax请求开始时会触发ajaxStart()方法的回调函数；当ajax请求结束时，会触发ajaxStop()方法的回调函数。这些方法都是全局的方法，因此无论创建它们的代码位于何处，只要有ajax请求发生时，都会触发它们。类似的事件还有：ajaxComplete(),ajaxError(),ajaxSend(),ajaxSuccess()等。 

如果使某个ajax请求不受全局方法的影响，那么可以在使用$.ajax()方法时，将参数中的global设置为false，jquery代码如下：$.ajax({    url:"test.html",    global:false//不触发全局ajax事件}) 

对于其他的ajax框架，解决用户访问请求超时这个问题的思路是类似的。 


---------------------------------------------------------------------------------------------------------------------------------------------
--转自http://sd1992585.iteye.com/blog/963428


extjs基于ajax实现，因为是异步请求，所以一般的jsp session过期跳转方式不可用，但是当它session过期时会手动去在页面头信息x-requested-with中插入XMLHttpRequest值,可以利用这

点去进行exjs的session过期处理。这里提供大家一个方法:

写一个Sessionfilter过滤器,检查是否session过期，过期时间通过web.xml配置（不明白具体步骤的上百度或者google详查）,



Java代码  


String head = httpRequest.getHeader("x-requested-with");(获得extjs session过期值)  

if (head != null && !(head.equalsIgnoreCase("XMLHttpRequest"))) {   

 if (sessionUser == null) {   

  httpResponse.sendError(999); //添加respone报错信息  

  filter.doFilter(httpRequest, httpResponse);   

 }  

 else{  

  filter.doFilter(httpRequest, httpResponse);   

 }  

}  

 

js中需要用到extjs中一个事件:



Js代码  


Ext.Ajax.on('requestexception',function(conn,response,options) {  

    if(response.status=="999"){  

        Ext.Msg.alert('提示', '会话超时，请重新登录!', function(){  

         var url = document.getElementById("atsurlid").value;  

            parent.location.href = url+'login.jsp';    

        });     

    }        

});  

 

然后可以实现session过期跳转。

一：前言：

最近支付后台登录一段时间后如果没有任何操作，总是需要重新登录才可以继续访问页面，出现这个问题的原因就是session超时，debug代码后发现session的超时时间是1800s。也就是说当1800秒内没有任何操作，session就会出现超时现象。那这个超时时间是如何设置的呢？然后该如何重新设置此超时时间呢？系统又如何判断session超时的呢？接下来就一一进行解答。

二：系统session超时时间如何默认的？

说明：获取session超时时间的方法为”request.getSession().getMaxInactiveInterval()"，但是tomcat中设置超时时间的参数为“sessionTimeout”，那么他们是怎么联系起来的呢？

第一步：加载sessionTimeout参数。

  1、项目运行初始化通过“@ConfigurationProperties”注解加载“org.springframework.boot.autoconfigure.web.ServerProperties”类。

//springBoot中默认的配置文件为"application.yml"或者"application.perties"文件，也就是说server是其中的一个配置参数。

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
      implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
//代码
}

2、上面类中“ServerProperties”继承自“EmbeddedServletContainerCustomizer”接口。重写customize方法，之后在此方法中“向上推”，即可找到“AbstractConfigurableEmbeddedServletContainer  ”类。

@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
   //多个参数判断，如果在application中没配置的情况下都是null
  if (getPort() != null) {
      container.setPort(getPort());
   }
  ...//n多个参数判断，
    //以下的代码就是重点，因为是tomcat容器，所以以下条件为“真”，经过一系列的查找父类或者实现接口即可找到抽象类“AbstractConfigurableEmbeddedServletContainer”
    //public class TomcatEmbeddedServletContainerFactory extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware
    //public abstract class AbstractEmbeddedServletContainerFactory  extends AbstractConfigurableEmbeddedServletContainer  implements EmbeddedServletContainerFactory 
   if (container instanceof TomcatEmbeddedServletContainerFactory) {
      getTomcat().customizeTomcat(this,
            (TomcatEmbeddedServletContainerFactory) container);
   }



//以上代码执行完成之后，实际上已经有对应的session所有的默认参数，之后通过下面方法，将所有参数放入对应的容器中。第3、4步就是设置过程

  container.addInitializers(new SessionConfiguringInitializer(this.session));

}

3、在“AbstractConfigurableEmbeddedServletContainer”类中终于可以找到“超时时间”的相关设置

//重要代码
//45行
private static final int DEFAULT_SESSION_TIMEOUT = (int) TimeUnit.MINUTES
      .toSeconds(30);
//66行
private int sessionTimeout = DEFAULT_SESSION_TIMEOUT;
 
@Override
public void setSessionTimeout(int sessionTimeout) {
   this.sessionTimeout = sessionTimeout;
}
//171-188行
@Override
public void setSessionTimeout(int sessionTimeout, TimeUnit timeUnit) {
   Assert.notNull(timeUnit, "TimeUnit must not be null");
   this.sessionTimeout = (int) timeUnit.toSeconds(sessionTimeout);
}

/**
 * Return the session timeout in seconds.
 * @return the timeout in seconds
 */
public int getSessionTimeout() {
   return this.sessionTimeout;
}

4、执行第2步的”container.addInitializers(new SessionConfiguringInitializer(this.session))“加载所有的配置参数。

public static class Session {

   /**
    * Session timeout in seconds.
    */
   private Integer timeout;

   public Integer getTimeout() {
      return this.timeout;
   }
//将session超时时间设置进来
   public void setTimeout(Integer sessionTimeout) {
      this.timeout = sessionTimeout;
   }

第二步：将上面的超时时间赋值给“MaxInactiveInterval”参数。

说明：既然上面tomcat需要的参数都已经加载完成，那么接下来就会运行tomcat，此处不做细讲，直接进入tomcat启动和加载参数说明。在“TomcatEmbeddedServletContainerFactory”类中的方法调用流程如下：

getEmbeddedServletContainer--》prepareContext--》configureContext--》configureSession--》getSessionTimeoutInMinutes。

1、调用configureSession设置tomcat的Session配置参数。

//以下代码
private void configureSession(Context context) {
   long sessionTimeout = getSessionTimeoutInMinutes();
   context.setSessionTimeout((int) sessionTimeout);
   Manager manager = context.getManager();
   if (manager == null) {
      manager = new StandardManager();
      //此处即为设置相应的参数的位置。之后会调用StandardContext类的setManger（Manager）方法，在setManger中会调用"manager.setContext(this)"
      context.setManager(manager);
   }
}



//计算超时时间为分钟（注意：此处会将之前的1800秒，转换为30分钟）。可以看出最终的时间结果是个整数的分钟类型，也就是说如果设置的超时时间（单位为秒）不是60的倍数，也会最终转换为60的倍数，并且最小超时时间设置的是60秒。

private long getSessionTimeoutInMinutes() {
   long sessionTimeout = getSessionTimeout();
   if (sessionTimeout > 0) {
      sessionTimeout = Math.max(TimeUnit.SECONDS.toMinutes(sessionTimeout), 1L);
   }
   return sessionTimeout;
}



2、最终将SessionTimeout赋值给MaxInactiveInterval。终于完成session超时时间设置。

//以下代码
@Override
public void setContext(Context context) {
    //省略其余设置代码，直接重新设置Session超时时间，此时又将上面的分钟单位转为秒。此时终于给Sesseion设置了默认超时时间。
    if (this.context != null) {
        setMaxInactiveInterval(this.context.getSessionTimeout() * 60);
        this.context.addPropertyChangeListener(this);
    }
}



三：如果自定义超时时间呢？

其实从上面的流程，已经不难看出，只需要在“org.springframework.boot.autoconfigure.web.ServerProperties”类中找到对应的Session参数，初始化让其加载上来即可完成设置。

/**
 * Get the session timeout.
 * @return the session timeout
 * @deprecated since 1.3.0 in favor of {@code session.timeout}.
 */
@Deprecated
@DeprecatedConfigurationProperty(replacement = "server.session.timeout")
public Integer getSessionTimeout() {
   return this.session.getTimeout();
}

所以在application中配置“server.session.timeout“即可，参数类型为long类型，单位为”秒“。

四：运行程序是如何判断session超时的？

其实很简单：只需要在每次本次同一个sessionequest请求的时间，和之前的请求时间进行比较，发现两个值的差已经大于MaxInactiveInterval的值即可。

//判断是否超时
@Override
public boolean isValid() {
    //省略多个条件判断
    if (maxInactiveInterval > 0) {
       //判断此session空闲时间是否比maxInactiveInterval大，如果大的情况下，session就超时
        int timeIdle = (int) (getIdleTimeInternal() / 1000L);
        if (timeIdle >= maxInactiveInterval) {
            expire(true);
        }
    }
    return this.isValid;
}

//将上次访问时间和当前时间比较，拿到空闲时间值
@Override
public long getIdleTimeInternal() {
    long timeNow = System.currentTimeMillis();
    long timeIdle;
    if (LAST_ACCESS_AT_START) {
        timeIdle = timeNow - lastAccessedTime;
    } else {
        timeIdle = timeNow - thisAccessedTime;
    }
    return timeIdle;
}



说明：

所以为了保证session超时时间长点，可以在application配置文件中配置“server.session.timeout”参数即可，参数单位为“秒”，如果参数不是60的整数倍，会转换成60的整数倍（见二：系统如何设置超时时间、步骤二中的“1”中算法）。如不满一分钟，会转换为60秒。

扩展：

实际上也可以直接重写EmbeddedServletContainerCustomizer的customize方法进行赋值。

 @Bean
 public EmbeddedServletContainerCustomizer containerCustomizer(){
        return new EmbeddedServletContainerCustomizer() {
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                 container.setSessionTimeout(600);//单位为S
           }
     };
 }