Using Directory Path as Parameters?

[Rob Mech]

I'd like to pull of a directory path to use that for parameters. Let me give an example


Servlet named "NewsInfo"

www.mysite.com/NewsInfo/Local/60146/

Basically I want to pull off the "Local" as a parameter and "60146" as a parameter. I don't want this to be a traditional parameter since many search engines rip off everything after the ? on a spider.

Any way to do this with a servlet or other J2EE technology?

[David O'Meara]

Yep, check the API for the other information available from the request, it's all there
(I'd give you the answer, but it isn't difficult and I think the time spent wandering the API is valuable )

[Rob Mech]

Originally posted by David O'Meara:
Yep, check the API for the other information available from the request, it's all there
(I'd give you the answer, but it isn't difficult and I think the time spent wandering the API is valuable )

Well I've done that already hense my post. I thought it had something to do with getContextPath but I wasnt sure how to apply that to the servlet itself. Hense my post.

Are you suggesting that getContextPath for the above URL would return everything after the servlet name? If so that's hardly clear from the API documentation for getContextPath.

[Bear Bibeault]

There are plenty of other methods on the request. Why not write a servlet that shows you what each returns?

[Rob Mech]

Originally posted by Bear Bibeault:
There are plenty of other methods on the request. Why not write a servlet that shows you what each returns?

Yeah, guess I could do that but then why did I bother posting a question on the friendly site for greenhorns. Seems pointless to ask a question to be told find it yourself.

[David O'Meara]

You're going to make me admit that I can't remember, aren't you?

I worked out how to do using Bear's method, you should give it a go

[Bear Bibeault]

Originally posted by Rob Mech:
Yeah, guess I could do that but then why did I bother posting a question on the friendly site for greenhorns. Seems pointless to ask a question to be told find it yourself.

There is nothing unfriendly about teaching a man how to fish. JavaRanch is primarily a learing site -- not someplace to just get an answer without understanding. You will much more often be led down a path of discovery rather than given a code snippet.

There's a big difference between "do it yourself" and "here's a clue to help you find out the answer to this, as well as similar questions in the future".

[Rob Mech]

Originally posted by Bear Bibeault:


There is nothing unfriendly about teaching a man how to fish. JavaRanch is primarily a learing site -- not someplace to just get an answer without understanding. You will much more often be led down a path of discovery rather than given a code snippet.

There's a big difference between "do it yourself" and "here's a clue to help you find out the answer to this, as well as similar questions in the future".

Agreed, but you dont show a person an ocean and say there it is either. I'd of been fine with the method of the api without the code snippet. Either way I'll find what I need elsewhere.

[Chris Corbyn]

This is fairly trivial really but I'm working on the same thing on and off so I'd be happy to post (GPL) code once it's done. If you want completely flexible (not set suffix or prefix) URLs then you end up having to do some jiggery-pokery with filters but it works.

To give you an idea on the interface:

XML configuration:

<?xml version="1.0" ?>
<!DOCTYPE router-mappings [
  <!ELEMENT router-mappings (mapping*)>
  <!ELEMENT mapping (name, description?, uri, parameter*, requirements*)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT uri (#PCDATA)>
  <!ELEMENT parameter (key, value)>
  <!ELEMENT key (#PCDATA)>
  <!ELEMENT value (#PCDATA)>
  <!ELEMENT requirement (key, value)>
]>
<!--
 
URL mapping schema definitions for the Mayo framework.
 
Each rule is known as a "mapping" (or a route).  You can have as many mappings as needed.
Each mapping needs to have at least a <name> and a <uri> element inside it.
The <url> element represents a pattern matching the request URI, excluding the
context-path part of the URL.  All <uri> patterns MUST begin with a forward slash "/".
In a URL, you may use :variableName to represent a wildcard for a request parameter's
value in the URL.  For example, "/:foo" would equate to a forward slash followed by 
the value of the "foo" paramater:
 
Unclean: ?foo=bar
Clean:   /bar
 
Variable names must start with a letter from A-Z (or a-z) or an underscore, followed by
A-Z, a-z, 0-9 or underscore none or more times.
 
You may append an asterisk to the end of the URL pattern like so:
 
/pattern/here/*
 
The asterisk is a greedy wildcard which can only occur at the very end of a URL.  It cleans
up any additional parameters not listed elsewhere in the pattern and maps them as:
 
/key1/value1/key2/value2/key3/value3
 
For example, the pattern "/:module/*" could map a completely clean URL:
 
/forum/threadId/52/searchByUser/1897
 
Which contains request parameters:
 
module       = forum
threadId     = 52
searchByUser = 1897
 
You may need to add some paramaters explicitly even if they're not visible in the URL. For
this you need to add a <parameter> element to your <route>.  See the IndexAction mapping
in this file for an example.  <parameter> basically injects parameters into the request. You
can have as many <parameter> tags as you need within any single mapping.
 
If a variable in your URL could be ambigious with another variable, you may need to distinguish
one from the other based upon a regular expression match.  You can specify pattern requirements
by adding one or more <requirement> elements to a mapping.  Requirements can only be specified
for variables already defined in the <uri> itself.
 
Requirements are describe like so:
 
<uri>/:foo/:bar</uri>
<requirement>
  <key>bar</key>
  <pattern>\d+</pattern>
</requirement>
 
In the above scenario, the pattern will only match if "bar" is a number.
 
Mappings are selected based upon the longest pattern and the number of parameters/requirements
they match.
 
-->
<router-mappings>
  <mapping>
    <name>Action</name>
    <description>
      This route maps the first two parts in the path with the module and action
    </description>
    <uri>/:module/:action/*</uri>
  </mapping>
  <mapping>
    <name>IndexAction</name>
    <description>
      Allows the module to be specified without the action for "Index" actions.
    </description>
    <uri>/:module</uri>
    <parameter>
      <key>action</key>
      <value>index</value>
    </parameter>
  </mapping>
  <mapping>
    <name>HomePage</name>
    <description>
      Handles the welcome page without any arguments in the URL.
    </description>
    <uri>/</uri>
    <parameter>
      <key>module</key>
      <value>home</value>
    </parameter>
    <parameter>
      <key>action</key>
      <value>index</value>
    </parameter>
  </mapping>
</router-mappings>

Factory class:

/**
 * A factory class used to provide instances of the router based on a configuration file.
 * @author Chris Corbyn <[e-mail]>
 * @license GNU General Public License
 */
 
package org.mayo.router;
 
import org.mayo.util.XmlReader;
import org.mayo.util.XmlReaderException;
import java.io.InputStream;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
 
/**
 * Creates instances of Router from a given configuration.
 */
public class RouterFactory {
  /**
   * The XML configuration InputStream.
   */
  protected InputStream inputStream;
  
  /**
   * Create a new instance from the given XML InputStream.
   * @param InputStream inputStream
   * @param HttpServletRequest request
   * @param HttpServletResponse response
   */
  public RouterFactory(InputStream inputStream) {
    setInputStream(inputStream);
  }
  /**
   * Get a new instance of the RouterFactory from the given XML InputStream.
   * @param InputStream inputStream
   * @return RouterFactory
   */
  public static RouterFactory newInstance(InputStream inputStream) {
    RouterFactory routerFactory = new RouterFactory(inputStream);
    return routerFactory;
  }
  /**
   * Sets the InputStream source.
   * @param InputStream inputStream
   */
  protected void setInputStream(InputStream inputStream) {
    this.inputStream = inputStream;
  }
  /**
   * Gets the InputStream instance.
   * @return InputStream
   */
  protected InputStream getInputStream() {
    return inputStream;
  }
  /**
   * Build a new instance of the Router based on the configuration.
   * @return Router
   * @throws RouterFactoryException If the configuration is invalid.
   */
  public Router createRouter() throws RouterFactoryException {
    Router router = new Router();
    try {
      String expr;
      InputStream inputStream = getInputStream();
      XmlReader reader = new XmlReader(inputStream);
      final String root = "/router-mappings";
      expr = root + "/mapping";
      if (!reader.nodeExists(expr)) {
        return router; //No mappings available
      }
      //There may be no routes at all
      NodeList routeNodes = reader.getNodes(expr);
      for (int i = 0, rLen = routeNodes.getLength(); i < rLen; i++) {
        Node routeNode = routeNodes.item(i);
        expr = "./name";
        if (!reader.nodeExists(expr, routeNode)) {
          throw new RouterFactoryException("Missing <name> in route number " + (i + 1) + ".");
        }
        String name = reader.getValue(expr, routeNode);
        expr = "./uri";
        if (!reader.nodeExists(expr, routeNode)) {
          throw new RouterFactoryException("Missing <uri> for route number " + (i + 1) + ".");
        }
        String uriPattern = reader.getValue(expr, routeNode);
        if (!uriPattern.substring(0, 1).equals("/")) {
          throw new RouterFactoryException(
            "<uri> pattern values must begin with a / character. Malformed pattern '" +
            uriPattern + "' for route number " + (i + 1) + ".");
        }
        RoutingRule rule = router.createRule(name, uriPattern);
        //Description is not important
        expr = "./description";
        String description = reader.getValue(expr, routeNode);
        rule.setDescription(description);
        //Parameters are optional so a NodeList of length 0 may be found
        expr = "./parameter";
        NodeList parameterNodes = reader.getNodes(expr, routeNode);
        for (int j = 0, pLen = parameterNodes.getLength(); j < pLen; j++) {
          Node parameterNode = parameterNodes.item(j);
          expr = "./key";
          if (!reader.nodeExists(expr, parameterNode)) {
            throw new RouterFactoryException("Missing <key> for parameter " + (j + 1) +
              " in route number " + (i + 1) + ".");
          }
          String key = reader.getValue(expr, parameterNode);
          expr = "./value";
          if (!reader.nodeExists(expr, parameterNode)) {
            throw new RouterFactoryException("Missing <value> for parameter " + (j + 1) +
              " in route number " + (i + 1) + ".");
          }
          String value = reader.getValue(expr, parameterNode);
          rule.addParameter(key, value);
        }
        //Requirements are optional so a NodeList of length 0 may be found
        expr = "./requirement";
        NodeList requirementNodes = reader.getNodes(expr, routeNode);
        for (int j = 0, pLen = requirementNodes.getLength(); j < pLen; j++) {
          Node requirementNode = requirementNodes.item(j);
          expr = "./key";
          if (!reader.nodeExists(expr, requirementNode)) {
            throw new RouterFactoryException("Missing <key> for requirement " + (j + 1) +
              " in route number " + (i + 1) + ".");
          }
          String key = reader.getValue(expr, requirementNode);
          expr = "./pattern";
          if (!reader.nodeExists(expr, requirementNode)) {
            throw new RouterFactoryException("Missing <pattern> for requirement " + (j + 1) +
              " in router number " + (i + 1) + ".");
          }
          String pattern = reader.getValue(expr, requirementNode);
          rule.addRequirement(key, pattern);
        }
        //Add the new rule
        router.addRule(rule);
      }
    } catch (XmlReaderException e) {
      throw new RouterFactoryException(e);
    }
    return router;
  }
}
 

The factory just reads the XML and builds a "Router" object with a list of "Rules". You need to wrap the request object in order for it to work to because the Map used by ServletRequest is immutable.
[ August 24, 2007: Message edited by: Chris Corbyn ]

[Rob Mech]

I was eventually able to get it to work. While the servlet api did have the method listed in it there was a change to web.xml that also had to be made.

[Edit: not-so-nice comment removed. Even if you do not agree with the approach being taken to try and help you answer your questions, please try to keep your tone civil.]
[ August 24, 2007: Message edited by: Bear Bibeault ]

[Bear Bibeault]

What change is that?

[Rob Mech]

Try building the servlet as I described and I'm sure you'll find out!

[Bear Bibeault]

I do this all the time and have never had to make any changes to the deployment descriptor.