Http connection Utilities : HttpURLConnection « Network « Java Tutorial






/**********************************************************************************
 *
 * Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
 *                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
 *
 * Licensed under the Educational Community License Version 1.0 (the "License");
 * By obtaining, using and/or copying this Original Work, you agree that you have read,
 * understand, and will comply with the terms and conditions of the Educational Community License.
 * You may obtain a copy of the License at:
 *
 *      http://cvs.sakaiproject.org/licenses/license_1_0.html
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **********************************************************************************/

import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

/**
 * HTTP utilites
 */
public class HttpTransactionUtils {

  private HttpTransactionUtils() {
  }

  /**
   * Default HTTP character set
   */
  public static final String DEFAULTCS = "ISO-8859-1";

  /*
   * Parameter handling
   */

  /**
   * Format one HTTP parameter
   * 
   * @param name
   *          Parameter name
   * @param value
   *          Parameter value (URLEncoded using default chracter set)
   * @return Parameter text (ampersand+name=url-encoded-value)
   */
  public static String formatParameter(String name, String value) {
    return formatParameter(name, value, "&", DEFAULTCS);
  }

  /**
   * Format one HTTP parameter
   * 
   * @param name
   *          Parameter name
   * @param value
   *          Parameter value (will be URLEncoded)
   * @param separator
   *          Character to separate parameters
   * @param cs
   *          Character set specification (utf-8, etc)
   * @return Parameter text (separator+name=url-encoded-value)
   */
  public static String formatParameter(String name, String value, String separator, String cs) {
    StringBuilder parameter = new StringBuilder();

    parameter.append(separator);
    parameter.append(name);
    parameter.append('=');

    try {
      parameter.append(URLEncoder.encode(value, cs));
    } catch (UnsupportedEncodingException exception) {
      throw new IllegalArgumentException("Invalid character set: \"" + cs + "\"");
    }

    return parameter.toString();
  }

  /*
   * HTTP status values
   */

  /**
   * Informational status?
   * 
   * @return true if so
   */
  public static boolean isHttpInfo(int status) {
    return ((status / 100) == 1);
  }

  /**
   * HTTP redirect?
   * 
   * @return true if so
   */
  public static boolean isHttpRedirect(int status) {
    return ((status / 100) == 3);
  }

  /**
   * Success status?
   * 
   * @return true if so
   */
  public static boolean isHttpSuccess(int status) {
    return ((status / 100) == 2);
  }

  /**
   * Error in request?
   * 
   * @return true if so
   */
  public static boolean isHttpRequestError(int status) {
    return ((status / 100) == 4);
  }

  /**
   * Server error?
   * 
   * @return true if so
   */
  public static boolean isHttpServerError(int status) {
    return ((status / 100) == 5);
  }

  /**
   * General "did an error occur"?
   * 
   * @return true if so
   */
  public static boolean isHttpError(int status) {
    return isHttpRequestError(status) || isHttpServerError(status);
  }

  /**
   * Set up a simple Map of HTTP request parameters (assumes no duplicate names)
   * 
   * @param request
   *          HttpServletRequest object
   * @return Map of name=value pairs
   */
  public static Map getAttributesAsMap(HttpServletRequest request) {
    Enumeration enumeration = request.getParameterNames();
    HashMap map = new HashMap();

    while (enumeration.hasMoreElements()) {
      String name = (String) enumeration.nextElement();

      map.put(name, request.getParameter(name));
    }
    return map;
  }

  /**
   * Format a base URL string ( protocol://server[:port] )
   * 
   * @param url
   *          URL to format
   * @return URL string
   */
  public static String formatUrl(URL url) throws MalformedURLException {
    return formatUrl(url, false);
  }

  /**
   * Format a base URL string ( protocol://server[:port][/file-specification] )
   * 
   * @param url
   *          URL to format
   * @param preserveFile
   *          Keep the /directory/filename portion of the URL?
   * @return URL string
   */
  public static String formatUrl(URL url, boolean preserveFile) throws MalformedURLException {
    StringBuilder result;
    int port;

    result = new StringBuilder(url.getProtocol());

    result.append("://");
    result.append(url.getHost());

    if ((port = url.getPort()) != -1) {
      result.append(":");
      result.append(String.valueOf(port));
    }

    if (preserveFile) {
      String file = url.getFile();

      if (file != null) {
        result.append(file);
      }
    }
    return result.toString();
  }

  /**
   * Pull the server [and port] from a URL specification
   * 
   * @param url
   *          URL string
   * @return server[:port]
   */
  public static String getServer(String url) {
    String server = url;
    int protocol, slash;

    if ((protocol = server.indexOf("//")) != -1) {
      if ((slash = server.substring(protocol + 2).indexOf("/")) != -1) {
        server = server.substring(0, protocol + 2 + slash);
      }
    }
    return server;
  }

  /*
   * urlEncodeParameters(): URL component specifications
   */

  /**
   * protocol://server
   */
  public static final String SERVER = "server";

  /**
   * /file/specification
   */
  public static final String FILE = "file";

  /**
   * ?parameter1=value1&parameter2=value2
   */
  public static final String PARAMETERS = "parameters";

  /**
   * /file/specification?parameter1=value1&parameter2=value2
   */
  public static final String FILEANDPARAMS = "fileandparameters";

  /**
   * Fetch a component from a URL string
   * 
   * @param url
   *          URL String
   * @param component
   *          name (one of server, file, parameters, fileandparameters)
   * @return URL component string (null if none)
   */
  public static String getUrlComponent(String url, String component) throws MalformedURLException {
    String file;
    int index;

    if (component.equalsIgnoreCase(SERVER)) {
      return getServer(url);
    }

    if (!component.equalsIgnoreCase(FILE) && !component.equalsIgnoreCase(PARAMETERS)
        && !component.equalsIgnoreCase(FILEANDPARAMS)) {
      throw new IllegalArgumentException(component);
    }

    file = new URL(url).getFile();
    if (file == null) {
      return null;
    }
    /*
     * Fetch file and parameters?
     */
    if (component.equalsIgnoreCase(FILEANDPARAMS)) {
      return file;
    }
    /*
     * File portion only?
     */
    index = file.indexOf('?');

    if (component.equalsIgnoreCase(FILE)) {
      switch (index) {
      case -1: // No parameters
        return file;
      case 0: // Only parameters (no file)
        return null;
      default:
        return file.substring(0, index);
      }
    }
    /*
     * Isolate parameters
     */
    return (index == -1) ? null : file.substring(index);
  }

  /**
   * URLEncode parameter names and values
   * 
   * @param original
   *          Original parameter list (?a=b&c=d)
   * @return Possibly encoded parameter list
   */
  public static String urlEncodeParameters(String original) {
    StringBuilder encoded = new StringBuilder();

    for (int i = 0; i < original.length(); i++) {
      String c = original.substring(i, i + 1);

      if (!c.equals("&") && !c.equals("=") && !c.equals("?")) {
        c = URLEncoder.encode(c);
      }
      encoded.append(c);
    }
    return encoded.toString();
  }

  /*
   * Test
   */
  public static void main(String[] args) throws Exception {
    String u = "http://example.com/dir1/dir2/file.html?parm1=1&param2=2";

    System.out.println("Server: " + getUrlComponent(u, "server"));
    System.out.println("File: " + getUrlComponent(u, "file"));
    System.out.println("Parameters: " + getUrlComponent(u, "parameters"));
    System.out.println("File & Parameters: " + getUrlComponent(u, "fileandparameters"));
    System.out.println("Bad: " + getUrlComponent(u, "bad"));
  }
}








19.6.HttpURLConnection
19.6.1.Get the date of a url connection
19.6.2.Get the document expiration date
19.6.3.Get the document Last-modified date
19.6.4.Show the content type
19.6.5.Show the content length
19.6.6.Display request method
19.6.7.Get response code
19.6.8.Display response message
19.6.9.Display header information
19.6.10.Download and display the content
19.6.11.A Web Page Source Viewer
19.6.12.Reading from a URLConnection
19.6.13.Use BufferedReader to read content from a URL
19.6.14.Check if a page exists
19.6.15.Identify ourself to a proxy
19.6.16.Connect through a Proxy
19.6.17.java.net.Authenticator can be used to send the credentials when needed
19.6.18.Read data from a URL
19.6.19.Dump a page using the HTTPS protocol
19.6.20.Save URL contents to a file
19.6.21.Http connection Utilities
19.6.22.Parsing and formatting HTTP dates as used in cookies and other headers.
19.6.23.Last Modified
19.6.24.URL connection and proxy
19.6.25.Http Constants
19.6.26.Http Header Helper
19.6.27.A utility class for parsing HTTP dates as used in cookies and other headers