Question on Filter

[Ravish Shankar]

Hi all,

Please find below a code I found in onjava regarding a Filter which avoids
multiple submits. Basically it queues the requests and always overwrites the
last request with the current waiting request in queue. Hence even if we
press 10 times, only first and last requests will be filtered. Its a nice
program. .

My question is how can we change this program, so that even the last request
will not be processed ? I do not want the processing to happen even two
times. I want to restrct the processing to only one time.**note that I do
not prefer a Java script client solution **. I tried many ways, but hits
balnk page or some exceptions. Please help ..

Best regards,
Ravi

-------

 
 import java.io.IOException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
 
public class SiteReentrantFilter implements Filter{
 
 
/**
* Use this filter to synchronize requests to your web application and
* reduce the maximum load that each individual user can put on your
* web application. Requests will be synchronized per session.  When more
* than one additional requests are made while a request is in process,
* only the most recent of the additional requests will actually be
* processed.
* <p>
* If a user makes two requests, A and B, then A will be processed first
* while B waits.  When A finishes, B will be processed.
* <p>
* If a user makes three or more requests (e.g. A, B, and C), then the
* first will be processed (A), and then after it finishes the last will
* be processed (C), and any intermediate requests will be skipped (B).
* <p>
* There are two additional limitiations:
* <ul>
*   <li>Requests will be excluded from filtering if their URI matches
*       one of the exclusion patterns.  There will be no synchronization
*       performed if a request matches one of those patterns.</li>
*   <li>Requests wait a maximum of 5 seconds, which can be overridden
*       per URI pattern in the filter's configuration.</li>
* </ul>
*
*/
 
  /**
   * Initialize this filter by reading its configuration parameters
   *
   * @param config  Configuration from web.xml file
   */
  public void init( FilterConfig config ) throws ServletException
  {
    // parse all of the initialization parameters, collecting the exclude
    // patterns and the max wait parameters
    Enumeration enum = config.getInitParameterNames();
    excludePatterns = new LinkedList();
    maxWaitDurations = new HashMap();
    while( enum.hasMoreElements() )
    {
      String paramName = ( String )enum.nextElement();
      String paramValue = config.getInitParameter( paramName );
      if( paramName.startsWith( "excludePattern" ) )
      {
        // compile the pattern only this once
        Pattern excludePattern = Pattern.compile( paramValue );
        excludePatterns.add( excludePattern );
      }
      else if( paramName.startsWith( "maxWaitMilliseconds." ) )
      {
        // the delay gets parsed from the parameter name
        String durationString = paramName.substring( 
"maxWaitMilliseconds.".length() );
        int endDuration = durationString.indexOf( '.' );
        if( endDuration != -1 )
        {
          durationString = durationString.substring( 0, endDuration );
        }
        Long duration = new Long( durationString );
 
        // compile the corresponding pattern, and store it with this delay 
in the map
        Pattern waitPattern = Pattern.compile( paramValue );
        maxWaitDurations.put( waitPattern, duration );
      }
    }
  }
 
  /**
   * Called with the filter is no longer needed.
   */
  public void destroy()
  {
    // there is nothing to do
  }
 
  /**
   * Synchronize the request and then either process it or skip it,
   * depending on what other requests current exist for this session.
   * See the description of this class for more details.
   */
  public void doFilter(
    ServletRequest request,
    ServletResponse response,
    FilterChain chain )
    throws IOException, ServletException
  {
    HttpServletRequest httpRequest = (HttpServletRequest)request;
    HttpServletResponse httpResponse = (HttpServletResponse)response;
    HttpSession session = httpRequest.getSession();
 
    // if this request is excluded from the filter, then just process it
    if( !isFilteredRequest( httpRequest ) )
    {
      chain.doFilter( request, response );
      return;
    }
 
    synchronized( getSynchronizationObject( session ) )
    {
      // if another request is being processed, then wait
      if( isRequestInProcess( session ) )
      {
        // Put this request in the queue and wait
        enqueueRequest( httpRequest, httpResponse );
        if( !waitForRelease( httpRequest ) )
        {
          // this request was replaced in the queue by another request,
          // so it need not be processed
          return;
        }
      }
 
      // lock the session, so that no other requests are processed until 
this one finishes
      setRequestInProgress( httpRequest );
    }
 
    // process this request, and then release the session lock regardless of
    // any exceptions thrown farther down the chain.
    try
    {
      chain.doFilter( request, response );
    }
    finally
    {
      releaseQueuedRequest( httpRequest );
    }
  }
 
  /**
   * Get a synchronization object for this session
   *
   * @param session
   */
  private static synchronized Object getSynchronizationObject(HttpSession 
session)
  {
    // get the object from the session.  If it does not yet exist,
    // then create one.
    Object syncObj = session.getAttribute( SYNC_OBJECT_KEY );
    if( syncObj == null )
    {
      syncObj = new Object();
      session.setAttribute( SYNC_OBJECT_KEY, syncObj );
    }
    return syncObj;
  }
 
  /**
   * Record that a request is in process so that the filter blocks 
additional
   * requests until this one finishes.
   *
   * @param request
   */
  private void setRequestInProgress(HttpServletRequest request)
  {
    HttpSession session = request.getSession();
    session.setAttribute( REQUEST_IN_PROCESS, request );
  }
 
  /**
   * Release the next waiting request, because the current request
   * has just finished.
   *
   * @param request   The request that just finished
   */
  private void releaseQueuedRequest( HttpServletRequest request )
  {
    HttpSession session = request.getSession();
    synchronized( getSynchronizationObject( session ) )
    {
      // if this request is still the current one (i.e., it didn't run for 
too
      // long and result in another request being processed), then clear it
      // and thus release the lock
      if( session.getAttribute( REQUEST_IN_PROCESS ) == request )
      {
        session.removeAttribute( REQUEST_IN_PROCESS );
        getSynchronizationObject( session ).notify();
      }
    }
  }
 
  /**
   * Is this server currently processing another request for this session?
   *
   * @param session   The request's session
   * @return          true if the server is handling another request for 
this session
   */
  private boolean isRequestInProcess( HttpSession session )
  {
    return session.getAttribute( REQUEST_IN_PROCESS ) != null;
  }
 
  /**
   * Wait for this server to finish with its current request so that
   * it can begin processing our next request.  This method also detects if
   * its request is replaced by another request in the queue.
   *
   * @param request   Wait for this request to be ready to run
   * @return  true if this request may be processed, or false if this
   *          request was replaced by another in the queue.
   */
  private boolean waitForRelease( HttpServletRequest request )
  {
    HttpSession session = request.getSession();
 
    // wait for the currently running request to finish, or until this
    // thread has waited the maximum amount of time
    try
    {
      getSynchronizationObject( session ).wait( getMaxWaitTime( request ) );
    }
    catch( InterruptedException ie )
    {
      return false;
    }
 
    // This request can be processed now if it hasn't been replaced
    // in the queue
 
    return request == session.getAttribute( REQUEST_QUEUE );
  }
 
  /**
   * Put a new request in the queue.  This new request will replace
   * any other requests that were waiting.
   *
   * @param request   The request to queue
   */
  private void enqueueRequest( HttpServletRequest request , 
HttpServletResponse response)
  {
    HttpSession session = request.getSession();
 
 
    // Put this request in the queue, replacing whoever was there before, if 
no match
  session.setAttribute( REQUEST_QUEUE,request );
 
 
     // if another request was waiting, notify it so it can discover that
    // it was replaced
    getSynchronizationObject( session ).notify();
  }
 
  /**
   * What is the maximum wait time (in milliseconds) for this request
   *
   * @param request
   * @return Maximum number of milliseconds to hold this request in the 
queue
   */
  private long getMaxWaitTime( HttpServletRequest request )
  {
    // look for a Pattern that matches the request's path
    String path = request.getRequestURI();
    Iterator patternIter = maxWaitDurations.keySet().iterator();
    while( patternIter.hasNext() )
    {
      Pattern p = (Pattern)patternIter.next();
      Matcher m = p.matcher( path );
      if( m.matches() )
      {
         // this pattern matches.  At most, how long can this request wait?
         Long maxDuration = (Long)maxWaitDurations.get( p );
         return maxDuration.longValue();
      }
    }
 
    // If no pattern matches the path, return the default value
    return DEFAULT_DURATION;
  }
 
  /**
   * Look through the filter's configuration, and determine whether or not 
it
   * should synchronize this request with others.
   *
   * @param httpRequest
   * @return
   */
  private boolean isFilteredRequest(HttpServletRequest request)
  {
    // iterate through the exclude patterns.  If one matches this path,
    // then the request is excluded.
    String path = request.getRequestURI();
    Iterator patternIter = excludePatterns.iterator();
    while( patternIter.hasNext() )
    {
      Pattern p = (Pattern)patternIter.next();
      Matcher m = p.matcher( path );
      if( m.matches() )
      {
        // at least one of the patterns excludes this request
        return false;
      }
    }
 
    // this path is not excluded
    return true;
  }
 
  /** A list of Pattern objects that match paths to exclude */
  private LinkedList excludePatterns;
 
  /** A map from Pattern to max wait duration (Long objects) */
  private HashMap maxWaitDurations;
 
  /** The session attribute key for the request currently being processed */
  private final static String REQUEST_IN_PROCESS
    = "SiteReentrantFilter.requestInProcess";
 
  /** The session attribute key for the request currently waiting in the 
queue */
  private final static String REQUEST_QUEUE
    = "SiteReentrantFilter.requestQueue";
 
  /** The session attribute key for the synchronization object */
  private final static String SYNC_OBJECT_KEY = 
"SiteReentrantFilter.sessionSync";
 
  /** The default maximum number of milliseconds to wait for a request */
  private final static long DEFAULT_DURATION = 5000;
 
 
}

[ February 04, 2007: Message edited by: Bear Bibeault ]

[Ravish Shankar]

Dear all,

Can anyone help on this ? Thanks

Regards,
Ravi

[Bear Bibeault]

One reason that you may not be getting much help on this is that you posted a large block of unformatted code. Who has the time to wade through all that?

When posting code to the Ranch, please do two things:

1) Pare the code down to the portion that is giving you trouble. If more will be needed to solve the problem, you'll get asked for it.

2) Use UBB code tags to preserve the formatting. Please read this for more info.

[Bear Bibeault]

I went ahead and added the UBB code tags to your post for you. Notice how much better the code is to read?

But it's still a lot of code to slog though...