Simple 2.0 - Java HTTP 引擎

/* * URIParser.java 1.0 February 2001 * * Copyright (C) 2001, Niall Gallagher <niallg@email.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the Free * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA */ package simple.util.parse; import simple.util.net.Path; import simple.util.net.URI; import java.util.Enumeration; import java.util.Hashtable; /** * This parser is used to parse uniform resource identifiers. * The uniform resource identifier syntax is given in RFC 2396. * This parser can parse relative and absolute URI's. The * uniform resource identifier syntax that this parser will * parse are based on the generic web based url similar to * the syntax represented in RFC 2616 section 3.2.2. The syntax * used to parse this URI is a modified version of RFC 2396 * <code><pre> * * URI = (absoluteURI | relativeURI) * absoluteURI = scheme ":" ("//" netpath | relativeURI) * relativeURI = path ["?" querypart] * netpath = domain [":" port] relativeURI * path = *("/" segment) * segment = *pchar *( ";" param ) * * </pre></code> * This implements the <code>URI</code> interface and provides * methods that access the various parts of the URI. The parameters * in the path segments of the uniform resource identifier are * stored in name value pairs. If parameter names are not unique * across the path segments then only the deepest parameter will be * stored from the path segment. For example if the URI represented * was <code>http://domain/path1;x=y/path2;x=z</code> the value for * the parameter named <code>x</code> would be <code>z</code>. * <p> * This will normalize the path part of the uniform resource * identifier. A normalized path is one that contains no back * references like "./" and "../". The normalized path will not * contain the path parameters. * <p> * The <code>setPath</code> method is used to reset the path this * uniform resource identifier has, it also resets the parameters. * The parameters are extracted from the new path given. * * @author Niall Gallagher * @version 1.0 */ public class URIParser extends Parser implements URI { /** * Used to buffer the characters that form the path. */ private ParseBuffer path; /** * Used to buffer the characters that form the domain. */ private ParseBuffer domain; /** * Used to buffer the characters that form the query. */ private ParseBuffer query; /** * Used to buffer the name characters of a parameter. */ private ParseBuffer name; /** * Used to buffer the value characters of a parameter. */ private ParseBuffer value; /** * References the scheme that this URI contains. */ private ParseBuffer scheme; /** * Used to normalize the path section of the URI. */ private PathParser parser; /** * Parameters are stored so that the can be viewed. */ private Hashtable param; /** * Indicates wheather the path part has beed parsed. */ private boolean isParsed; /** * Contains the port number if it was specified. */ private int port; /** * Default constructor will create a <code>URIParser</code> * that contains no specifics. The instance will return * <code>null</code> for all the get methods. The parsers * get methods are populated by using the <code>parse</code> * method. */ public URIParser(){ this(32); } /** * This constructor is used so that the memory used by the parser * can be optimized. This will set the <code>ParseBuffer</code> * lengths to be the length specified. This allows for the use of * the <code>URIParser(String)</code> constructor to maximize * its efficency so that a <code>ParseBuffer.expandCapacity</code> * will not be needed if they are too short. This also helps if * the path being parsed is small. It enables little memory to * be used when only little memory is needed. * <p> * This can also be used when the <code>URIParser</code> object * is a static or singelton instance. If the parser is used with * <code>URIParser.parse(String)</code> many times it is best to * keep a large length so a <code>ParseBuffer.expandCapacity</code> * will not be needed for an arbitrary input. * * @param len this is used so that the <code>URIParser</code> * can be used more efficently */ public URIParser(int len) { path = new ParseBuffer(len); parser = new PathParser(); domain = new ParseBuffer(); query = new ParseBuffer(); scheme = new ParseBuffer(); name = new ParseBuffer(); value = new ParseBuffer(); param = new Hashtable(); } /** * This is primarily a convineance constructor. This will parse * the <code>String</code> given to extract the specifics. This * could be achived by calling the default no-arg constructor * and then using the instance to invoke the <code>parse</code> * method on that <code>String</code> to extract the parts. * * @param uri a <code>String</code> containing a uri value */ public URIParser(String uri){ this(uri.length()); parse(uri); } /** * This is used to retrive the domain of this URI. The * domain part in the URI is an optional part, an example * <code>http://domain/path?querypart</code>. This will * return the value of the domain part. If there is no * domain part then this will return null otherwise the * domain value found in the uniform resource identifier. * * @return the domain part of this uniform resource * identifier this represents */ public String getDomain(){ if(domain.length() == 0){ return null; } return domain.toString(); } /** * This is used to retrive the path of this URI. The path part * is the most fundemental part of the URI. This will return * the value of the path. If there is no path part then this * will return <code>/</code> to indicate the root. * <p> * The <code>Path</code> object returned by this will contain * no path parameters. The path parameters are available using * the <code>URI</code> methods. The reason that this does not * contain any of the path parameters is so that if the path is * needed to be converted into ab OS specific path then the path * parameters will not need to be seperately parsed out. * * @return the path that this URI contains, this value will not * contain any back references such as "./" and "../" or any * path parameters */ public Path getPath(){ if(path.length() == 0){ parser.parse("/"); } else if(!isParsed) { parser.parse("" + path); isParsed = true; } return parser; } /** * This is used to retrive the port of the uniform resource * identifier. The port part in this is an optional part, an * example <code>http://host:port/path?querypart</code>. This * will return the value of the port. If there is no port then * this will return <code>-1</code> because this represents * an impossible uniform resource identifier port. The port * is an optiona