An Introduction To Java Servlets

An Introduction to Java Servlet
K. Yue April 15, 2001

Introduction

Web server side technology comparable to CGI programming.
Brief comparison with CGI, ASP, PHP and Cold Fusion

Performance:

Servlets may be loaded once and they can then respond to multiple client requests.
Each client request is executed in its own thread, rather than in a new process.
Java code is compiled to byte-code first.
Java is still slower than C/C++.

Servlets have session-tracking capabilities allowing state information to be saved across requests during some time period.
Portability: servlets offer greater platform independence and server independence
Advantages of Java: use Enterprise Java Bean (EJB) as the component model.
Like CGI, it is programming language-oriented, not presentation-oriented.
Excellent multi-platform support.

Use JDK 1.1+ and Tomcat or Java Servlet Development Kit (JSDK).
If Tomcat or JSDK is not installed in your development workstation, you can try the following:
- Copying the jar files to your current directory where you store your java file.
- use the classpath option of javac to specifiy classpath. For example:

javac -classpath ./servlet.jar;./server.jar MyProg.java

Primary abstraction in the JSDK is the Servlet interface.
Servlets typically extend GenericServlet and HttpServlet which implement this interface

Servlet Lifecycle

A Java Servlet engine performs the following:

Create and initialize servlets.
Handle any number of service calls from clients through the servlets.
Destroy and garbage collect the servlets.

A Java servlet is loaded when the page is first accessed. A Java Servlet is reloaded when necessary (such as when the new Java class has been updated.)

Writing Java Servlets

Defining Servlets

Servlets may implement the javax.servlet.Servlet interface directly.
More likely, Java servlets extend HttpServlet which supports standard HTTP/1.1 requests by dispatching them to a method that can handle a particular request protocol.
HttpServlet by default handles multiple client requests concurrently.
To disengage this activity, a servlet may also implement the SingleThreadModel interface.
No extra methods are required to force iterative execution

Example: skeleton

import javax.servlet.*;
import javax.servlet.http.*;

public class MyIterativeServlet extends HttpServlet
                                implements SingleThreadModel {
   /* Servlet which handles client requests iteratively */
   ...
}

The service method may be overridden directly to operate on client requests

Example: SimpleHello.java

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

public class SimpleHello extends HttpServlet {
public void service(ServletRequest request, ServletResponse response)
   throws ServletException, IOException
   {
       response.setContentType("text/html");
       PrintWriter toClient = response.getWriter();
       toClient.println("<html>");
       toClient.println("<p>Hello, world</p>");
       toClient.println("</html>");
       toClient.close();
   }
}

However, it is usually not overridden. The default implementation of the service method is to dispatch the client request to the proper doXXX methods.

javax.servlet.http.HttpServletResponse

The ServletResponse Interface provides for sending MIME data from the servlet's service method to the client.
The two most commonly used methods of ServletResponse are:

setContentType - sets the content type; must be done before sending any response data.
getWriter - returns PrintWriter to be used to return data.

HttpServletResponse contains 12 additional methods, such as AddCookie.

Example: SetCookie.java

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class SetCookie extends HttpServlet {
   public void service(HttpServletRequest request, HttpServletResponse response)
       throws ServletException, IOException
   {   // set a cookie
       String name = "last_visited";
       String value = (new Date()).toString();
       Cookie cookie = new Cookie(name, value);
       cookie.setMaxAge(1000000);
       response.addCookie(cookie);
       response.setContentType("text/html");
       PrintWriter toClient = response.getWriter();
       toClient.println("<html>");
       toClient.println("<p>A cookie has been set: ");
       toClient.println(name + " => " + value + ".");
       toClient.println("</html>");
       toClient.close();
   }
}

javax.servlet.http.HttpServletRequest

HttpServletRequest provides HTTP header and the client data.
Client data can be accessed by one (but not both) of the following methods:

Method group #1 (more popular)

getParameterNames - provides the names of the parameters as an enumeration (for any HTTP method).
getParameterValues - provides the value of a named parameter as a string array (any method).

Method group #2 (mainly for file upload).

getQueryString - returns a String to be parsed (for GET methods)
getReader - returns a BufferedReader for text data (POST, PUT, DELETE methods)
getInputStream - returns a ServletInputStream for binary data (POST, PUT, DELETE methods)

Example 1: ParameterSnoop.java

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

public class ParameterSnoop extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
   res.setContentType("text/plain");
   PrintWriter out = res.getWriter();

   out.println("Query String:");
   out.println(req.getQueryString());
   out.println();

   out.println("Request Parameters:");
   Enumeration enum = req.getParameterNames();
   while (enum.hasMoreElements()) {
      String name = (String) enum.nextElement();
      String values[] = req.getParameterValues(name);
      if (values != null) {
         for (int i = 0; i < values.length; i++) {
            out.println(name + " (" + i + "): " + values[i]);
         }
      }
   }
}
}

Example: GetCookie.java

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

public class GetCookie extends HttpServlet {
public void service(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException
{ // get all cookies
   Cookie[] cookies = request.getCookies();
   String name = "";
   String value = "";
   response.setContentType("text/html");
   PrintWriter toClient = response.getWriter();
   toClient.println("<html>");
   if (cookies != null) {
      toClient.println("<p><ul>The following cookies found: ");
      for (int i=0; i<cookies.length; i++) {
         name = cookies[i].getName();
         value = cookies[i].getValue();
         toClient.println("<li>" + name + " => " + value + ".");
      }
      toClient.println("</ul>");
   }
   else {
      toClient.println("There is no cookie.");
   }
   toClient.println("</html>");
   toClient.close();
}
}

Handling HTTP Requests

HTTP servlets specializing the HttpServlet class typically override only the methods which handle HTTP interaction rather than the service method:

doGet - for GET, conditional GET and HEAD requests
doPost - for POST requests
doPut - for PUT requests
doDelete - for DELETE requests

These HTTP methods return BAD_REQUEST (400) by default.
Two other methods provided are typically not overridden:

doTrace - for TRACE requests; by default returns all the headers sent in the trace request
doOptions - for OPTIONS requests; by default returns what HTTP options are supported

Regardless of the method(s) overridden, they all take specialized ServletRequest and ServletResponse objects as parameters (HttpServletRequest, HttpServletResponse)

Example: Hello.java

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Hello extends HttpServlet {
   public void doGet(HttpServletRequest req, HttpServletResponse res)
                throws ServletException, IOException {
    // Set the Content-Type header
    res.setContentType("text/html");

    // Return early if this is a HEAD method. Note that doHead calls
    // doGet by default.
    if (req.getMethod().equals("HEAD")) return;

    PrintWriter out = res.getWriter();
    String name = req.getParameter("name");
    // generate the dynamic HTML contents.
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Hello, " + name + "</TITLE></HEAD>");
    out.println("<BODY>");
    out.println("Hello, " + name);
    out.println("</BODY></HTML>");
}
public void doPost(HttpServletRequest req, HttpServletResponse res)
                                throws ServletException, IOException {
    doGet(req, res);
}
}

More details on Java Servlet Life-Cycle

Initialization

Upon client request or at startup, the servlet’s init method is executed.
An argument ServletConfig is passed to init().
There is no concurrency issues here because the service calls the init method only one time upon loading it, and cannot call it again unless it is reloading it.
A servlet cannot be reload until it has been removed by calling the destroy method.

Client requests

Handled by the service method. each request is run in its own servlet thread.
Multiple service methods can run at any time, therefore concurrency issues must be resolved.
To disallow concurrent processing of client requests, the servlet must implement the SingleThreadModel interface.

Destruction

When removing a servlet, the servlet’s destroy method is run once and cannot run again until the servlet is reloaded and reinitialized.
At the same time the destroy method is executed, other threads may be running service requests.
Access to shared resources must be synchronized to ensure proper destruction of the servlet.

Example: InitDestroyCounter.java

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

public class InitDestroyCounter extends HttpServlet {

int count;
String counterFileName = "InitDestroyCounter.initial";
public void init(ServletConfig config) throws ServletException {
    // Always call super.init(config) first (servlet mantra #1)
    super.init(config);

    // Try to load the initial count from our saved persistent state
    try {
      FileReader fileReader = new FileReader(counterFileName);
      BufferedReader bufferedReader = new BufferedReader(fileReader);
      String initial = bufferedReader.readLine();
      count = Integer.parseInt(initial);
      return;
    }
    catch (FileNotFoundException ignored) { } // no saved state
    catch (IOException ignored) { }            // problem during read
    catch (NumberFormatException ignored) { } // corrupt saved state
    String initial = getInitParameter("initial");
    try {
      count = Integer.parseInt(initial);
      return;
    }
    catch (NumberFormatException ignored) { }
// null or non-integer value

    // Default to an initial count of "0"
    count = 0;
}

public void doGet(HttpServletRequest req, HttpServletResponse res)
                               throws ServletException, IOException {
    //   Here, I change it to HTML.
    res.setContentType("text/html");
    PrintWriter out = res.getWriter();

    int local_count;
    synchronized(this) {
      local_count = ++count;
      if (count % 10 == 0) saveState();
    }
    out.println("<html><body bgcolor=#ccccff>" +
                "Since loading, this servlet has been accessed " +
                local_count + " times. See you.</body></html>");
}

public void destroy() {
    saveState();
}

public void saveState() {
    // Try to save the accumulated count
    try {
      FileWriter fileWriter = new FileWriter(counterFileName);
      String initial = Integer.toString(count);
      fileWriter.write(initial, 0, initial.length());
      fileWriter.close();
      return;
    }
    catch (IOException e) { // problem during write
      // Log the exception.
    }
}
}