November 23, 2014
Hot Topics:

The Servlet Container Model

  • October 24, 2002
  • By Que Publishing
  • Send Email »
  • More Articles »

The GET is the most common type of browser request. According to the Hypertext Transfer Protocol standard, the GET method means "retrieve whatever information (in the form of an entity) is identified by the Request-URI." For a full discussion on naming and addressing (URL vs. URI) please see http://www.w3.org/Addressing/. If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity in the response and not the source text of the process, unless that text happens to be the output of the process." In our example, the test message is the entity.


GET Method

The GET is the most common type of browser request. The GET request is defined by the Internet Society's RFC 2616: Hypertext Transfer Protocol—HTTP/1.1. See section 9.3 of RFC 2616 at ftp://ftp.isi.edu/in-notes/rfc2616.txt.


This method is where your servlet does most of its labor. You could process a simple HTML response or hit a database with a query.

Table 4.1 provides a list of differences between GET and POST requests.

Table 4.1 GET vs. POST Request

GET

POST

Query string or form data is simply appended to the URL as name-value pairs.

Form name-value pairs are sent in the body of the request, not in the URL itself.

Query length is limited (~1KB).

Query length is unlimited.

Users can see data in address bar.

Data hidden from users.

http://mycompany.com/support?
Name=John+Smith&Product=go+ kart&Complaint=the+engine+ is+sputtering+oil
.

http://mycompany.com/support
<values of Name, Product, and Complaint are in request body>.

doGet().

doPost().

For getting (retrieving) data only.

For causing a change on the server (store data in DB).

ASCII.

ASCII + Binary.

Easy to bookmark.

Hard to bookmark.

Used more.

Used less.


The following short listings exemplify the GET and POST requests

<html>
 <body>
 <form method="GET" action="/myservlet/process">
  <input type="text" name="product" size="25"
  maxlength="35" value="type product name here">
  <input type="submit" name="submitButton" value="Submit">
 </form>
 </body>
</html>
<html>
 <body>
 <form method="post" action="/myservlet/process">
  <input type="text" name="product" size="25"
  maxlength="35" value="type product name here">
  <input type="submit" name="submitButton" value="Submit">
 </form>
 </body>
</html>

POST

The POST type request is most often used by HTML forms. It has this syntax:

  public void doPost(HttpServletRequest request,
           HttpServletResponse response)
    throws IOException, ServletException
    { //your code here}

The POST method is more sophisticated than a GET request. Normally, a Web form has fields whose names and values are sent to the server in key-value pairs. The POST is designed for posting long messages (for example, to a bulletin board, newsgroup, mailing list); providing a block of data, such as the result of submitting a form; and submitting long data fields to a database (such as a SQL insert of lengthy string). Sometimes the action performed by the POST method doesn't return a standard HTML page. Suppose you updated a database table. The database doesn't send back an HTML confirmation on its own. You would have to wrap the database results in HTML manually. You also have the option of sending back an empty response with a header status of either 200 (OK) or 204 (No Content). A No Content status tells the browser that it shouldn't expect any HTML. You might want to do this if it is software to software interaction and no eyeballs are waiting to see a Web page.


POST Method

The POST is the most sophisticated of the methods covered by this part of the exam. The POST request is defined by the Internet Society's RFC 2616: Hypertext Transfer Protocol—HTTP/1.1. See section 9.5 of RFC 2616 at ftp://ftp.isi.edu/in-notes/rfc2616.txt.


Normally, this method is used to process a form submitted by a browser. You will very likely be looking for form field names and values. For example, the following snippet is how you would grab the value of the field formCountField that the user supplied a value for:

//read the query string
int customerRequest = 0;
String count = request.getParameter("formCountField");
try 
{
  customerRequest = Integer.parseInt(count);
} catch (Exception e) 
{ // NumberFormat or NullPointerException
  processError(e);
}  

PUT

The PUT type request is a means of uploading files to the server. While uploading is its original intent, I have not seen it used much. Instead, POST is generally used to upload files. The PUT handler has this syntax:

  public void doPut(HttpServletRequest request,
           HttpServletResponse response)
    throws IOException, ServletException
    { //your code here}

The doPut() method is called by the server (via the service method) to handle a PUT request. Uploading files from a browser has always been difficult. The idea behind the PUT operation is to make uploading straightforward. It is supposed to allow a client to place a file on the server, just like sending a file by FTP. The javadoc for this method warns that when overriding this method, you should leave intact any content headers sent with the request (including Content-Length, Content-Type, Content-Transfer-Encoding, Content-Encoding, Content-Base, Content-Language, Content-Location, Content-MD5, and Content-Range). This method is rarely used, but it is powerful if you need it.

Listing 4.5 is a simplified HTML page that creates a file upload page that will direct the file contents to a servlet.

Listing 4.5 HTML Form Example

<html>
<body>
<form enctype="multipart/form-data" method="PUT"
action="localhost:8080/examples/servlet/UploadServlet">
<input type="file" size="20" name="FileToUpload"
value="Select File">
<input type="submit" name="UploadFile" value="Upload">
<input type="reset" value="Reset">
</form>
</body>
</html>

Listing 4.6 is a servlet that can accept an uploaded file.

Listing 4.6 Servlet That Handles a File Upload from the Client

import java.io.*;
import java.util.*; 
import java.net.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class UploadServlet extends HttpServlet 
{
    static final String dir="C:/temp";
    
    public void doPut(HttpServletRequest req, 
    HttpServletResponse res)
    throws ServletException, IOException
    {
     PrintWriter outHTML = res.getWriter();
     outHTML.println("done");
        
     try 
     {
        int i;
        InputStream input;
        input = req.getInputStream();
        BufferedInputStream in = 
           new BufferedInputStream(input);
        BufferedReader reader = 
           new BufferedReader(
             new InputStreamReader(in));
        File outputFile = 
           new File("c:/temp/out.txt");
        FileWriter out = 
           new FileWriter(outputFile);
    
        while ((i = reader.read()) != -1) 
        {
          out.write(i);
        }
    
        out.close();
        in.close();
    
      }
      catch (IOException e) {}
    }
}

You need to account for the header and footer lines that the stream attaches to the actual file contents. The stream looks like this:

------------BB1rHqKAOHkiUoiFS3VI6v
Content-Disposition: form-data; name="FileToUpload"; 
                 filename="Candle.txt"
Content-Type: application/octet-stream; name="Candle. txt"

// ...
//actual file content here
// ...

------------BB1rHqKAOHkiUoiFS3VI6v
Content-Disposition: form-data; name="UploadFile"

Upload
------------BB1rHqKAOHkiUoiFS3VI6v

Therefore, you will need to search (indexOf) for the start of the actual file content by looking for the Content-Type and subsequent name parameters like so:

int headerEnd = line.indexOf("Content-Type: ");
headerEnd = line.indexOf("name=\"", headerEnd); 
headerEnd = line.indexOf("\"", headerEnd + 7); //last quote

Likewise, you need to search the end of the file for the telltale Content-Disposition and preceding "------------" marker like so:

int footerStart = 
       line.lastIndexOf ("Content- Disposition: ");
footerStart = line.lastIndexOf ("---------", footerStart); 

Lastly, you will grab the text between the two like so:

fileContent = line.substring(headerEnd, footerStart);

You can refer to RFC 1867 to learn more about uploading files through an HTML form (http://www.servlets.com/rfcs/rfc1867.html). This is all tedious, so you might just grab an open source (http://www.servlets.com/cos/index.html) or commercial Bean that uploads files such as uploadBean (http://www.javazoom.net/jzservlets/uploadbean/uploadbean.html) or jspSmartUpload (http://www.jspsmart.com/).

Listing 4.6 worked when placed in the doPost() method (and the form method of Listing 4.5 is set to post), but did not work in the doPut() method using IE or Opera against Tomcat (version 4). I verified that the doPut() method is called as expected in the servlet. However, even after much tweaking, this file upload code failed when placed in the doPut method as shown previously. If you only change doPut to doPost it works?! Although I need to research this problem with Tomcat, you do need to understand that PUT is used to upload files to a Web server and that this is usually done by non-browser, client-side Web content development tools.

Triggering HttpServlet GET, POST, and PUT Methods

1.2 For each of the HTTP methods, GET, POST, and HEAD, identify triggers that might cause a browser to use the method, and identify benefits or functionality of the method.

GET

POST

HEAD

This exam objective focuses on what triggers the events or methods in your servlets. For example, what action can a client take that results in the doGet() method being called in your servlet?

GET

As noted previously, the GET type request is normally used for simple HTML page requests. The types of events that generate this type of request are clicking on a hyperlink, changing the address directly by typing in the address textbox on a browser or application that has HTML functionality, and submitting an HTML form where the method header is set to get as in method=get. Also, a GET request is triggered when selecting a favorite from the Favorites list and using JavaScript to change location.href. Usually the browser is configured to send a GET request even if no method is set explicitly by the HTML.

The benefits of the GET method are

  • It retrieves information such as a simple HTML page or the results of a database query.

  • It supports query strings (name-value pairs appended to URL). Servers usually limit query strings to about 1000 characters.

  • It allows bookmarks.

POST

This occurs when a browser or application submits an HTML form with the method attribute set to post as in method=post.

The benefits of the POST method are

  • It sends information to the server such as form fields, large text bodies, and key-value pairs.

  • It hides form data because it isn't passed as a query string, but in the message body.

  • It sends unlimited length data as part of its HTTP request body.

  • It disallows bookmarks.

HEAD

A browser or application will sometimes send a request to a server just to check the status or get information (for example, "can you handle file upload?") from the server.

The HEAD method returns the same header lines that a GET method would return; however, no body or content is returned. This is often accomplished by calling doGet(), setting the headers but not setting any output, and then returning the response (without any body) to the requester.

The primary benefit of this method is message size. The HEAD method receives and returns very small messages. Therefore it is fast and lightweight on both ends.

Interfacing with HTML Requests

In this section we deal with interfacing with HTML requests: how to process them and how to return a response to one. Since the HTTP client is sending the request, how do you know what it wants? While the container handles things like parsing the request and placing the information into a Request object, sometimes you have manually code processing routines. This section tells you how to write these routines that perform actions such as retrieve HTML form parameters, request headers, servlet initialization parameters, and redirects.

1.3 For each of the following operations, identify the interface and method name that should be used to

  • Retrieve HTML form parameters from the request
  • Retrieve a servlet initialization parameter
  • Retrieve HTTP request header information
  • Set an HTTP response header; set the content type of the response
  • Acquire a text stream for the response
  • Acquire a binary stream for the response
  • Redirect an HTTP request to another URL

This is a broad-stroke objective. It is asking you to be familiar with the most important servlet interfaces and their methods. Thankfully, this objective reduces the task from remembering almost 1,000 methods to just a few of them, which happen to be the most interesting ones.

Form Parameters

The interface that defines the form parameter methods is ServletRequest. This interface is implemented by the Web container to get the parameters from a request. Parameters are sent in the query string or posted form data. The four methods associated with getting parameters are

  • getParameter(String). You use this method if you know the particular parameter name. It returns the value of a request parameter as a string, or null if the parameter does not exist. Use this method when you are sure the parameter has only one value; otherwise use getParameterValues(). Be careful: If you use this method with a multivalued parameter, you won't get an error. You will get the first value in the array returned by getParameterValues().

  • getParameterMap(). You use this method to create a map of the form parameters supplied with this request.

  • getParameterNames(). This one returns an Enumeration of string objects containing the names of the parameters contained in this request, or an empty Enumeration if the request has no parameters.

  • getParameterValues(String). This method returns an array of values as strings, or null if the parameter does not exist. If the parameter has a single value, the array has a length of 1. One of the common uses of getParameterValues() is for processing <select> lists that have their "multiple" attribute set.

Listing 4.7, the following code snippet, demonstrates how you would grab the parameters from a request.

Listing 4.7 Servlet That Walks the Request Parameter List

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class ShowRequestParameters extends HttpServlet 
{
  public void doPost(HttpServletRequest request, 
           HttpServletResponse response)
  throws IOException, ServletException
  {
    Enumeration parameterNames = 
           request.getParameterNames();

    // acquire text stream for response
    PrintWriter out = res.getWriter ();

    while (parameterNames.hasMoreElements()) {
      String name = 
        (String)parameterNames.nextElement();
      String value = request.getParameter(name);
      out.println(name + " = " + value + "<br/>");
    }
  }
}

Retrieving a Servlet Initialization Parameter

A Web application includes many parts; it rarely is just one class or file. It can be a combination of JSP pages, servlets, tag libraries, Java beans, and other class files. The Java Virtual Machine creates a memory box for all of these called a ServletContext object which maintains information (context) about your Web application. You access the ServletContext for information about the application state. As the API states, the ServletContext allows you access many types of information. You can get application-level initialization parameters. You can also set and get application attributes, as well as the major and minor version of the Servlet API that this Servlet Container supports. One very interesting capability is to get hold of RequestDispatcher object to forward requests to other application components within the server, or to include responses from certain components within the servlet and to log a message to application log file. The ServletContext object is how you can set, get, and change application (not session) level attributes and talk to the Servlet Container.

Context means application scope. The getInitParameter and getInitParameterNames methods retrieve context-wide, application-wide, or "Web application" parameters. The getInitParameter method returns a string containing the value of the parameter (you provide the name), or null if the parameter does not exist.

Some parameters have no information, so this method will return a string containing at least the Servlet Container name and version number. The getInitParameterNames method retrieves the names of the servlet's initialization parameters as an Enumeration of string objects. If there aren't any, it returns an empty Enumeration. Be careful; don't confuse this with session-wide attributes.

Listing 4.8 shows an example of displaying servlet initialization parameters.

Listing 4.8 Servlet That Walks the Context Initialization Parameter List

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.*;
import javax.servlet.http.*;

public class InitializationParameters extends HttpServlet 
{
  /**
   * Print servlet configuration init. parameters.
   *
   * @param request The servlet request we are processing
   * @param response The servlet response we are creating
   *
   * @exception IOException if an input/output error
   * @exception ServletException for a 
   * servlet-specified error
   */
  public void doGet(HttpServletRequest request,
           HttpServletResponse response)
    throws IOException, ServletException 
  {

    response.setContentType("text/html");
    PrintWriter writer = response.getWriter();

    // servlet configuration initialization parameters
    writer.println("<h1>ServletConfig " +
            "Initialization Parameters</h1>");
    writer.println("<ul>");
    Enumeration params = 
        getServletConfig().getInitParameterNames();
    while (params.hasMoreElements()) 
    {
      String param = (String) params.nextElement();
      String value = 
        getServletConfig().getInitParameter(param);
      writer.println("<li><b>" + param + 
              "</b> = " + value);
    }
    writer.println("</ul>");
    writer.println("<hr>");
   }
}

Retrieving HTTP Request Header Information

The request header is where all the details of the request are bundled. This is where the browser specifies the file wanted, date, image file support, and more. Listing 4.9 shows a popular way to display the header parameters by walking through an Enumeration of them.

Listing 4.9 Servlet That Displays the HTTP Header Information

import java.io.*;
import java.text.*; 
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

/**
 * Displaying request headers
 *
 * @author Reader@Que
 */

public class DisplayRequestHeaders extends HttpServlet {

  public void doGet(HttpServletRequest request,
           HttpServletResponse response)
    throws IOException, ServletException
  {
    response.setContentType("text/html");

    PrintWriter out = response.getWriter();
    out.println("<html>");
    out.println("<head>");

    String title = "Requestheader Example";
    out.println("<title>" + title + "</title>");
    out.println("</head>");
    out.println("<body>");

    out.println("<h3>" + title + "</h3>");
    out.println("<table>");
    Enumeration e = request.getHeaderNames();
    while (e.hasMoreElements()) 
    {
      String headerName = (String)e.nextElement();
      String headerValue = 
              request.getHeader(headerName);
      out.println("<tr><td bgcolor=\"#CCCCCC\">" + 
             headerName);
      out.println("</td><td>" + headerValue + 
            "</td></tr>");
    }
    out.println("</table>");
    out.println("</body>");
    out.println("</html>");
  }
}

The output of this listing looks like Figure 4.4.

Figure 4.4
You can retrieve request header information using a servlet.





Page 2 of 5



Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Enterprise Development Update

Don't miss an article. Subscribe to our newsletter below.

Sitemap | Contact Us

Rocket Fuel