HttpUtilspublic class HttpUtils extends Object
Fields Summary |
---|
private static final String | LSTRING_FILE | private static ResourceBundle | lStrings |
Constructors Summary |
---|
public HttpUtils()Constructs an empty HttpUtils object.
|
Methods Summary |
---|
public static java.lang.StringBuffer | getRequestURL(javax.servlet.http.HttpServletRequest req)Reconstructs the URL the client used to make the request,
using information in the HttpServletRequest object.
The returned URL contains a protocol, server name, port
number, and server path, but it does not include query
string parameters.
Because this method returns a StringBuffer ,
not a string, you can modify the URL easily, for example,
to append query parameters.
This method is useful for creating redirect messages
and for reporting errors.
StringBuffer url = new StringBuffer ();
String scheme = req.getScheme ();
int port = req.getServerPort ();
String urlPath = req.getRequestURI();
//String servletPath = req.getServletPath ();
//String pathInfo = req.getPathInfo ();
url.append (scheme); // http, https
url.append ("://");
url.append (req.getServerName ());
if ((scheme.equals ("http") && port != 80)
|| (scheme.equals ("https") && port != 443)) {
url.append (':");
url.append (req.getServerPort ());
}
//if (servletPath != null)
// url.append (servletPath);
//if (pathInfo != null)
// url.append (pathInfo);
url.append(urlPath);
return url;
| private static java.lang.String | parseName(java.lang.String s, java.lang.StringBuffer sb)
sb.setLength(0);
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '+":
sb.append(' ");
break;
case '%":
try {
sb.append((char) Integer.parseInt(s.substring(i+1, i+3),
16));
i += 2;
} catch (NumberFormatException e) {
// XXX
// need to be more specific about illegal arg
throw new IllegalArgumentException();
} catch (StringIndexOutOfBoundsException e) {
String rest = s.substring(i);
sb.append(rest);
if (rest.length()==2)
i++;
}
break;
default:
sb.append(c);
break;
}
}
return sb.toString();
| public static java.util.Hashtable | parsePostData(int len, javax.servlet.ServletInputStream in)Parses data from an HTML form that the client sends to
the server using the HTTP POST method and the
application/x-www-form-urlencoded MIME type.
The data sent by the POST method contains key-value
pairs. A key can appear more than once in the POST data
with different values. However, the key appears only once in
the hashtable, with its value being
an array of strings containing the multiple values sent
by the POST method.
The keys and values in the hashtable are stored in their
decoded form, so
any + characters are converted to spaces, and characters
sent in hexadecimal notation (like %xx) are
converted to ASCII characters.
// XXX
// should a length of 0 be an IllegalArgumentException
if (len <=0)
return new Hashtable(); // cheap hack to return an empty hash
if (in == null) {
throw new IllegalArgumentException();
}
//
// Make sure we read the entire POSTed body.
//
byte[] postedBytes = new byte [len];
try {
int offset = 0;
do {
int inputLen = in.read (postedBytes, offset, len - offset);
if (inputLen <= 0) {
String msg = lStrings.getString("err.io.short_read");
throw new IllegalArgumentException (msg);
}
offset += inputLen;
} while ((len - offset) > 0);
} catch (IOException e) {
throw new IllegalArgumentException(e.getMessage());
}
// XXX we shouldn't assume that the only kind of POST body
// is FORM data encoded using ASCII or ISO Latin/1 ... or
// that the body should always be treated as FORM data.
//
try {
String postedBody = new String(postedBytes, 0, len, "8859_1");
return parseQueryString(postedBody);
} catch (java.io.UnsupportedEncodingException e) {
// XXX function should accept an encoding parameter & throw this
// exception. Otherwise throw something expected.
throw new IllegalArgumentException(e.getMessage());
}
| public static java.util.Hashtable | parseQueryString(java.lang.String s)Parses a query string passed from the client to the
server and builds a HashTable object
with key-value pairs.
The query string should be in the form of a string
packaged by the GET or POST method, that is, it
should have key-value pairs in the form key=value,
with each pair separated from the next by a & character.
A key can appear more than once in the query string
with different values. However, the key appears only once in
the hashtable, with its value being
an array of strings containing the multiple values sent
by the query string.
The keys and values in the hashtable are stored in their
decoded form, so
any + characters are converted to spaces, and characters
sent in hexadecimal notation (like %xx) are
converted to ASCII characters.
String valArray[] = null;
if (s == null) {
throw new IllegalArgumentException();
}
Hashtable ht = new Hashtable();
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(s, "&");
while (st.hasMoreTokens()) {
String pair = (String)st.nextToken();
int pos = pair.indexOf('=");
if (pos == -1) {
// XXX
// should give more detail about the illegal argument
throw new IllegalArgumentException();
}
String key = parseName(pair.substring(0, pos), sb);
String val = parseName(pair.substring(pos+1, pair.length()), sb);
if (ht.containsKey(key)) {
String oldVals[] = (String []) ht.get(key);
valArray = new String[oldVals.length + 1];
for (int i = 0; i < oldVals.length; i++)
valArray[i] = oldVals[i];
valArray[oldVals.length] = val;
} else {
valArray = new String[1];
valArray[0] = val;
}
ht.put(key, valArray);
}
return ht;
|
|