nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

Site Pre-Controller Execution Time

chucktuesday

I'm trying to write a handler for missing files that intelligently redirects the browser or rewrites the request depending on the situation. The logic is all worked out but the problem is that a site pre-controller only runs once the page's existence had been verified. The essentially ruins what I was trying to do. Is there any place I can hook in that occurs before it checks to see if the page file is there?

Thanks!

Chuck

Find more posts tagged with

Comments

AlexC

You will need to write a filter and chain it into web.xml to handle your tests then forward them to next filter (which would be the livesite one).

chucktuesday

Thanks! I figured that's the way it would end up and started writing that way right after I posted this message.

FYI - I ended up having to write a pretty hefty HttpServletRequestWrapper to handle the forward since I needed to change the path and querystring.


package com.sample.requests;

import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.StringTokenizer;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import org.apache.catalina.Globals;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class FilterForwardableHttpServletRequest  extends HttpServletRequestWrapper {

@SuppressWarnings("unchecked")
 LinkedHashMap params = null;
 HttpServletRequest originalRequest = null;
 String baseURL = null;
 String servletPath = null;
 StringBuffer requestURL = null;

 private static Log log = LogFactory.getLog(FilterForwardableHttpServletRequest.class);

 public FilterForwardableHttpServletRequest(HttpServletRequest request) {
        super(request);
        copyRequestDataFromParent(request);
        setServletPath(request.getServletPath());
        loadParameters(request.getParameterMap());
    }

 public FilterForwardableHttpServletRequest(HttpServletRequest request, String servletPath, String queryString) {
        super(request);
        copyRequestDataFromParent(request);
        setServletPath(servletPath);
        loadParameters(queryString);
    }

    private void copyRequestDataFromParent(HttpServletRequest request) {
        this.originalRequest = request;
        StringBuffer url = request.getRequestURL();
        int p = url.indexOf("/", request.getScheme().length() + 3);
        if (p >= 0) {
         baseURL = url.substring(0, p);
        }
    }

@Override
 public String getParameter(String name) {
        String returnValue = null;
        String[] paramArray = getParameterValues(name);
        if (paramArray != null && paramArray.length > 0){
          returnValue = paramArray[0];   
        }
        return returnValue;
    }

@SuppressWarnings("unchecked")
@Override
 public Map getParameterMap() {
        return Collections.unmodifiableMap(params);
    }

@SuppressWarnings("unchecked")
@Override
 public Enumeration getParameterNames() {
        return Collections.enumeration(params.keySet());        
    }

@Override
 public String[] getParameterValues(String name) {
     String[] result = null;
     String[] temp = (String[])params.get(name);
     if (temp != null){
      result = new String[temp.length];
      System.arraycopy(temp, 0, result, 0, temp.length);      
     }
        return result;
    }

    public void setParameter(String name, String value) {
     setParameter(name, value, true);
    }

    public void setParameter(String name, String value, boolean overwrite) {
     String[] temp = (String[])params.get(name);
     if (temp == null || overwrite) {
      String[] oneParam = {value};
      setParameter(name, oneParam);
     }
     else {
      String[] multiParams = new String[temp.length + 1];
      System.arraycopy(temp, 0, multiParams, 0, temp.length);
      multiParams[temp.length] = value;
      setParameter(name, multiParams);
     }
    }

@SuppressWarnings("unchecked")
 public void setParameter(String name, String[] values){
      params.put(name, values);   
    }

@Override
 public StringBuffer getRequestURL() {
     StringBuffer requestURL = null;
        requestURL = new StringBuffer();
        requestURL.append(baseURL).append(servletPath);
     return requestURL;  
    }

@Override
 public String getRequestURI() {
     return servletPath;
    }

@Override
 public String getServletPath() {
     return servletPath;  
    }

    public void setServletPath(String servletPath) {
     this.servletPath = servletPath;  
  setAttribute(Globals.INCLUDE_SERVLET_PATH_ATTR, servletPath);
        requestURL = new StringBuffer();
        requestURL.append(baseURL).append(servletPath);
    }

@Override
@SuppressWarnings("unchecked")
 public String getQueryString() {
     StringBuffer result = new StringBuffer();
     boolean haveFirst = false;
     String key = null;
     String value = null;
     String encodedValue;
     for (Iterator itr = params.keySet().iterator(); itr.hasNext(); ) {
      if (haveFirst) { result.append("&"); } else { haveFirst = true; }
      key = (String) itr.next();
         value = getParameter(key);
      try {
       encodedValue = URLEncoder.encode(value, "UTF-8");
      }
      catch (UnsupportedEncodingException e) {
       encodedValue = getParameter(key);
         log.error("Error encoding querystring element - value=\"" + value + "\"", e);
      }
   result.append(key).append("=").append(encodedValue);
  }
     return result.toString();
    }

@SuppressWarnings("unchecked")
 public void loadParameters(Map map) {
  this.params = new LinkedHashMap(map);
    }

@SuppressWarnings("unchecked")
 public void loadParameters(String queryString)
    {
        this.params = new LinkedHashMap();
  if (queryString != null && queryString.length() > 0) {
          String content = queryString.replace('+', ' ');
          StringTokenizer st = new StringTokenizer(content, "&");

          while (st.hasMoreTokens())
          {
               String token = st.nextToken();
               int i = token.indexOf("=");
               String name = token.substring(0, i);
               String value = token.substring(i+1);

               try {
                name = URLDecoder.decode(name, "UTF-8");
                value = URLDecoder.decode(value, "UTF-8");
                setParameter(name, value, false);
               }
               catch (UnsupportedEncodingException e) {
          log.error("Error decoding querystring element - value=\"" + value + "\"", e);
               }
          }
         }
    }

}

It's used like this...


hsRequest = new FilterForwardableHttpServletRequest(
 hsRequest, 
 newPath, 
 newQuerystring
);
chain.doFilter(hsRequest, hsResponse);