Projects Free With Source Code

Popup Button

2011-05-04T20:17:00.000+05:30

A PopupButton Component written by
Pat Paternostro
JDJ 5-10 p82

Listing 1
import java.awt.*;
import java.awt.event.*;

public abstract class PopupButton extends Button implements ActionListener
{
private PopupMenu popup;

protected PopupButton(String[] items, Container parent)
{
this("",items,parent);
}

protected PopupButton(String label, String[] items, Container parent)
{
super(label + " Û ");

popup = new PopupMenu();

MenuItem menuItems[] = new MenuItem[items.length];

for(int i = 0; i < items.length; i++)
{
menuItems[i] = new MenuItem(items[i]);
menuItems[i].addActionListener(this);
popup.add(menuItems[i]);
}

parent.add(popup);

addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
popup.show(PopupButton.this,0,PopupButton.this.getSize().height);}});
}
}

Listing 2
import java.awt.event.*;
import java.awt.*;

public class PopupButtonTest {
public static void main(String args[]) {
new PopupButtonTestFrame();
}
}

class PopupButtonTestFrame extends Frame {
Panel panel = new Panel();
MyPopupButton mpb1 = new MyPopupButton("Colors",new String[]{"Red","Green","Blue"},this);
MyPopupButton mpb2 = new MyPopupButton("Fruit",new String[]{"Apples","-","Oranges","-","Bannanas"},this);

PopupButtonTestFrame() {
super();

/* Add the window listener */
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) {
dispose(); System.exit(0);}});

/* Size the frame */
setSize(200,200);

/* Center the frame */
Dimension screenDim = Toolkit.getDefaultToolkit().getScreenSize();
Rectangle frameDim = getBounds();
setLocation((screenDim.width - frameDim.width) / 2,(screenDim.height - frameDim.height) / 2);

panel.add(mpb1);
panel.add(mpb2);
add(BorderLayout.NORTH,panel);

/* Show the frame */
setVisible(true);
}
}

class MyPopupButton extends PopupButton
{
public MyPopupButton(String label, String[] items, Container parent)
{
super(label,items,parent);
}

public void actionPerformed(ActionEvent evt)
{
String command = evt.getActionCommand(); System.out.println("You selected the " + command + "
popup menu item!");
}
}

Creating Thread-Safe Servlets

2011-04-30T22:57:00.001+05:30

A servlet container allows multiple requests for the same servlet by creating a different thread to service each request. In many cases, each thread deals with its own ServletRequest and ServletResponse objects that are isolated from other threads. Problems start to arise, however, when your servlet needs to access an external resource. To understand the problem introduced by multithreaded servlets, consider the following "playing dog" illustration.

Imagine a servlet accessing an external resource as a dog who enjoys moving tennis balls from one box to another. Each box can hold ten balls, no matter how the balls are arranged. The boxes and the balls are an external resource to the dog. To play, the dog needs two boxes and ten balls. Initially, those ten balls are placed in the first box. The dog moves all balls from the first box to the second, one ball at a time. The dog is smart enough to count to ten. Therefore, it knows when it's finished.

Now imagine a second thread of the same servlet as a second dog that plays the same game. Because there are only two boxes and ten balls for both dogs, the two dogs share the same "external resource." The game goes like this:

The first dog starts first (the servlet receives a call from a user).
After the first dog moves three balls, the second dog starts to play (the servlet is invoked by the second user). What will happen?

The two dogs sharing the same balls are illustrated in Figure 2.6.

Figure 2.6. Understanding multi-threaded code.

The first dog and the second dog will not find enough balls to finish the game, and both will be confused.

If somehow the second dog can be queued to wait to start until the first dog finishes, however, the two dogs are happy.

That's what happens when two threads of the same servlet need to access an external resource, such as opening a file and writing to it. Consider the following example, which reflects a real-world situation.

The code in Listing 2.13 presents a page counter servlet. What it does is simple. The servlet overrides the service method to do the following:

Open the counter.txt file using a BufferedReader, read the number into a counter, and close the file.
Increment the counter.
Write the counter back to the counter.txt file.
Display the counter in the web browser.

Imagine what happens if there are two users, Boni and Bulbul, who request the servlet. First Boni requests it, and then a couple of nanoseconds after Boni, Bulbul requests the same servlet. The scenario probably looks like this:

The service method executes Steps 1 and 2, and then gets distracted by the other request.
The method then does Step 1 from Bulbul before continuing to do Step 3 and 4 for Boni.

What happens next? Boni and Bulbul get the same number, which is not how it is supposed to be. The servlet has produced an incorrect result. As you can see in Listing 2.13, the servlet is an unsafe multithreaded servlet.

Listing 2.13 Unsafe Multi-Threaded Servlet

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

public class SingleThreadedServlet extends GenericServlet 
  {

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
    int counter = 0; 

    // get saved value 
    try {
      BufferedReader reader = new BufferedReader(
        new FileReader("counter.txt")); 
        counter = Integer.parseInt( reader.readLine() ); 
        reader.close(); 
      } 
      catch (Exception e) {
      } 

      // increment counter 
      counter++; 

      // save new value 
      try {
        BufferedWriter writer = new BufferedWriter(
          new FileWriter("counter.txt")); 
        writer.write(Integer.toString(counter)); 

        writer.close(); 
      } 
      catch (Exception e) {
      } 

      try {
        PrintWriter out = response.getWriter(); 
        out.println("You are visitor number " + counter); 
      } 
      catch (Exception e) {
      } 
   } 
}

To solve the problem, remember the solution to the "playing dog" illustration: When the second dog waited until the first dog finished playing, both dogs could complete the game successfully.

This is exactly how you solve the problem in a servlet needing to service two users at the same time: by making the second user wait until the first servlet finishes serving the first user. This solution makes the servlet single-threaded.

This solution is very easy to do because of the marker SingleThreadedServlet interface. You don't need to change your code; you need only to implement the interface.

The code in Listing 2.14 is the modification of the code in Listing 2.13. Nothing changes, except that the SingleThreadedServlet class now implements SingleThreadModel, making it thread safe.

Listing 2.14 Safe Multi-Threaded Servlet

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

public class SingleThreadedServlet extends GenericServlet 
  implaments SingleThreadModel {

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
    int counter = 0; 

    // get saved value 
    try {
      BufferedReader reader = new BufferedReader(
        new FileReader("counter.txt")); 
      counter = Integer.parseInt( reader.readLine() ); 
      reader.close(); 
    } 
    catch (Exception e) {
    } 

    // increment counter 
    counter++; 

    // save new value 
    try {
      BufferedWriter writer = new BufferedWriter(
        new FileWriter("counter.txt")); 
      writer.write(Integer.toString(counter)); 

      writer.close(); 
    } 
    catch (Exception e) {
    } 

    try {
      PrintWriter out = response.getWriter(); 
      out.println("You are visitor number " + counter); 
    } 
    catch (Exception e) {
    } 
  } 
}

Now, if a user requests the service of the servlet while the servlet is servicing another user, the user who comes later will have to wait.

If you want to experience erroneous multi-threading yourself, the code in Listing 2.15 provides the SingleThreadedServlet with a delay of 6 seconds. Open two browsers and request the same servlet quickly. Notice that you get the same number for both browsers.

Listing 2.15 Demonstrating an Unsafe Multi-Threaded Servlet

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

public class SingleThreadedServlet extends GenericServlet {

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
    int counter = 0; 

    // get saved value 
    try {
      BufferedReader reader = new BufferedReader(
        new FileReader("counter.txt")); 
      counter = Integer.parseInt( reader.readLine() ); 
      reader.close(); 
    } 
    catch (Exception e) {
    } 

    // increment counter 
    counter++; 

    // delay for 6 seconds to make observation possible 
    try {
      Thread thread = new Thread(); 
      thread.sleep(6000); 
    } 
    catch (InterruptedException e) {
    } 

    // saved new value 
    try {
      BufferedWriter writer = new BufferedWriter(
        new FileWriter("counter.txt")); 
      writer.write(Integer.toString(counter)); 

      writer.close(); 
    } 
    catch (Exception e) {
    } 

    try {
      PrintWriter out = response.getWriter(); 
      out.println("You are visitor number " + counter); 
    } 
    catch (Exception e) {
    } 
  } 
}

What the code does is simple: It opens the counter.txt file, reads the value, increments the value, and writes the incremented value back to the file.

However, between the line of code that increments the value and the line of code that writes the incremented value back to the user, we inserted the following code:

try {
  Thread thread = new Thread(); 
  thread.sleep(6000); 
} 
catch (InterruptedException e) {
}

Now you have time to request the same servlet from the second browser. The value shown in both browsers will be the same if the second request comes before the first thread of the servlet has the time to update the value in the counter.txt file.

An inexperienced programmer would wonder whether a good solution might be to make every servlet implement the SingleThreadModel interface. The answer is no. If a servlet never accesses an external resource, queuing the second request will create unnecessary delay to the subsequent user after the first. Also, if the external resource is accessed but there is no need to update its value, you don't need to implement the SingleThreadModel interface. For example, if the service method of a servlet needs only to read a static value from a file, you can let multiple threads of the servlet open and read the file at the same time.

The GenericServlet Wrapper Class

2011-04-30T22:55:00.001+05:30

Throughout this chapter, you have been creating servlet classes that implement the javax.servlet.Servlet interface. Everything works fine, but there are two annoying things that you've probably noticed:

You have to provide implementations for all five methods of the Servlet interface, even though most of the time you only need one. This makes your code look unnecessarily complicated.
The ServletConfig object is passed to the init method. You need to preserve this object to use it from other methods. This is not difficult, but it means extra work.

The javax.servlet package provides a wrapper class called GenericServlet that implements two important interfaces from the javax.servlet package: Servlet and ServletConfig, as well as the java.io.Serializable interface. The GenericServlet class provides implementations for all methods, most of which are blank. You can extend GenericServlet and override only methods that you need to use. Clearly, this looks like a better solution.

The code in Listing 2.12 is a servlet called SimpleServlet that extends GenericServlet. The code provides the implementation of the service method that sends some output to the browser. Because the service method is the only method you need, only this method needs to appear in the class. Compared to all servlet classes that implement the javax.servlet.Servlet interface directly, SimpleServlet looks much cleaner and clearer.

Listing 2.12 Extending GenericServlet

import javax.servlet.*; 
import java.io.IOException; 
import java.io.PrintWriter; 

public class SimpleServlet extends GenericServlet {

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {

    PrintWriter out = response.getWriter(); 
    out.println("<HTML>"); 
    out.println("<HEAD>"); 
    out.println("<TITLE>"); 
    out.println("Extending GenericServlet"); 
    out.println("</TITLE>"); 
    out.println("</HEAD>"); 
    out.println("<BODY>"); 
    out.println("Extending GenericServlet makes your code simpler."); 
    out.println("</BODY>"); 
    out.println("</HTML>"); 
  } 
}

The output from the SimpleServlet servlet is shown in Figure 2.5.

Figure 2.5. Extending GenericServlet.

The ServletResponse Interface

2011-04-30T22:52:00.001+05:30

The ServletResponse interface represents the response to the user. The most important method of this interface is getWriter, from which you can obtain a java.io.PrintWriter object that you can use to write HTML tags and other text to the user.

The code in Listings 2.10 and 2.11 offer an HTML file named index2.html and a servlet whose service method is overridden with code that outputs some HTML tags to the user. This servlet modifies the example in Listings 2.8 and 2.9 that retrieves various information about the user. Instead of sending the information to the console, the service method sends it back to the user.

Note that the code in Listing 2.10 is similar to the code in Listing 2.8, except that in Listing 2.10 the value for the form's ACTION attribute is servlet/ResponseDemoServlet.

Listing 2.10 index2.html

<HTML> 
<HEAD> 
<TITLE>Sending a request</TITLE> 
</HEAD> 
<BODY> 
<FORM ACTION=servlet/ResponseDemoServlet METHOD="POST"> 
<BR><BR> 
Author: <INPUT TYPE="TEXT" NAME="Author"> 
<INPUT TYPE="SUBMIT" NAME="Submit"> 
<INPUT TYPE="RESET" VALUE="Reset"> 
</FORM> 
</BODY> 
</HTML>

Listing 2.11 The ResponseDemoServlet

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

public class ResponseDemoServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
  } 
  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {

    PrintWriter out = response.getWriter(); 
    out.println("<HTML>"); 
    out.println("<HEAD>"); 
    out.println("<TITLE>"); 
    out.println("ServletResponse"); 
    out.println("</TITLE>"); 
    out.println("</HEAD>"); 
    out.println("<BODY>"); 
    out.println("<B>Demonstrating the ServletResponse object</B>"); 
    out.println("<BR>"); 

    out.println("<BR>Server Port: " + request.getServerPort()); 
    out.println("<BR>Server Name: " + request.getServerName()); 
    out.println("<BR>Protocol: " + request.getProtocol()); 
    out.println("<BR>Character Encoding: " + request.getCharacterEncoding()); 
    out.println("<BR>Content Type: " + request.getContentType()); 
    out.println("<BR>Content Length: " + request.getContentLength()); 
    out.println("<BR>Remote Address: " + request.getRemoteAddr()); 
    out.println("<BR>Remote Host: " + request.getRemoteHost()); 
    out.println("<BR>Scheme: " + request.getScheme()); 
    Enumeration parameters = request.getParameterNames(); 
    while (parameters.hasMoreElements()) {
      String parameterName = (String) parameters.nextElement(); 
      out.println("<br>Parameter Name: " + parameterName); 
      out.println("<br>Parameter Value: " + 
        request.getParameter(parameterName)); 
    } 
    Enumeration attributes = request.getAttributeNames(); 
    while (attributes.hasMoreElements()) {
      String attribute = (String) attributes.nextElement(); 
      out.println("<BR>Attribute name: " + attribute); 
      out.println("<BR>Attribute value: " + request.getAttribute(attribute)); 
    } 
    out.println("</BODY>"); 
    out.println("</HTML>"); 
  } 

  public String getServletInfo() {
    return null; 
  } 

  public ServletConfig getServletConfig() {
    return null; 
  } 

}

To run the example, first request the index2.html file by using the following URL:

http://localhost:8080/myApp/index2.html

Figure 2.3 shows the index2.html file in which "haywood" has been typed in as the value for author.

Figure 2.3. The index2.html file.

When you submit the form, the ResponseDemoServlet is invoked and your browser should display an image similar to Figure 2.4.

Figure 2.4. Utilizing the ServletResponse object.

The ServletRequest Interface

2011-04-30T22:48:00.001+05:30

Requests and responses are what a web application is all about. In a servlet application, a user using a web browser sends a request to the servlet container, and the servlet container passes the request to the servlet.

In a servlet paradigm, the user request is represented by the ServletRequest object passed by the servlet container as the first argument to the service method. The service method's second argument is a ServletResponse object, which represents the response to the user.

The ServletRequest Interface

The ServletRequest interface defines an object used to encapsulate information about the user's request, including parameter name/value pairs, attributes, and an input stream.

The ServletRequest interface provides important methods that enable you to access information about the user. For example, the getParameterNames method returns an Enumeration containing the parameter names for the current request. To get the value of each parameter, the ServletRequest interface provides the getParameter method.

The getRemoteAddress and getRemoteHost methods are two methods that you can use to retrieve the user's computer identity. The first returns a string representing the IP address of the computer the client is using, and the second method returns a string representing the qualified host name of the computer.

The following example, shown in Listings 2.8 and 2.9, shows a ServletRequest object in action. The example consists of an HTML form in a file named index.html that you need to put in the application directory—that is, under myApp—and a servlet called RequestDemoServlet.

Listing 2.8 index.html

<HTML> 
<HEAD> 
<TITLE>Sending a request</TITLE> 
</HEAD> 
<BODY> 
<FORM ACTION=servlet/RequestDemoServlet METHOD="POST"> 
<BR><BR> 
Author: <INPUT TYPE="TEXT" NAME="Author"> 
<INPUT TYPE="SUBMIT" NAME="Submit"> 
<INPUT TYPE="RESET" VALUE="Reset"> 
</FORM> 
</BODY> 
</HTML>

Listing 2.9 RequestDemoServlet

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

public class RequestDemoServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
  } 

  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {

    System.out.println("Server Port: " + request.getServerPort()); 
    System.out.println("Server Name: " + request.getServerName()); 
    System.out.println("Protocol: " + request.getProtocol()); 
    System.out.println("Character Encoding: " + 
      request.getCharacterEncoding()); 
    System.out.println("Content Type: " + request.getContentType()); 
    System.out.println("Content Length: " + request.getContentLength()); 
    System.out.println("Remote Address: " + request.getRemoteAddr()); 
    System.out.println("Remote Host: " + request.getRemoteHost()); 
    System.out.println("Scheme: " + request.getScheme()); 
    Enumeration parameters = request.getParameterNames(); 
    while (parameters.hasMoreElements()) {
      String parameterName = (String) parameters.nextElement(); 
      System.out.println("Parameter Name: " + parameterName); 
      System.out.println("Parameter Value: " + 
        request.getParameter(parameterName)); 
    } 
    Enumeration attributes = request.getAttributeNames(); 
    while (attributes.hasMoreElements()) {
      String attribute = (String) attributes.nextElement(); 
      System.out.println("Attribute name: " + attribute); 
      System.out.println("Attribute value: " + 
        request.getAttribute(attribute)); 
    } 
  } 

  public String getServletInfo() {
    return null; 
  } 

  public ServletConfig getServletConfig() {
    return null; 
  } 

}

To run the example, first request the index.html file by using the following URL:

http://localhost:8080/myApp/index.html

Figure 2.2 shows the index.html file in which "haywood" has been typed in as the value for author.

Figure 2.2. The index.html file.

When you submit the form, you should see the list of attribute names and values in your console.

Sharing Information Among Servlets

2011-04-30T22:47:00.001+05:30

For some applications, you want to make certain types of information available to all the servlets. You can share this information—such as a database connection string or a page count—among the servlets by using attributes in the ServletContext object.

The following example uses two servlets: AttributeSetterServlet and DisplayAttributesServlet. The AttributeSetterServlet servlet, shown in Listing 2.6, binds the name password to a String object containing the word "ding-dong". The servlet does this by first obtaining the ServletContext object from the ServletConfig object passed by the servlet container to the init method. Then the servlet uses the setAttribute method to bind "password" with "ding-dong".

Listing 2.6 The AttributeSetterServlet

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

public class AttributeSetterServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
    // bind an object that is to be shared among other servlets 
    ServletContext servletContext = config.getServletContext(); 
    servletContext.setAttribute("password", "dingdong"); 
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
  } 

  public void destroy() {
  } 

  public String getServletInfo() {
    return null; 
  } 
  public ServletConfig getServletConfig() {
    return null; 
  } 
}

The code in Listing 2.7 is the servlet that retrieves all attribute name/value pairs in the ServletContext object. The init method of this servlet preserves the ServletConfig object into servletConfig. The service method then uses the ServletConfig interface's getServletContext method to obtain the ServletContext object. After you get the ServletContext object, you can then use its getAttributeNames method to get an Enumeration of all attribute names and loop through it to obtain each attribute's value, which it outputs to the console along with the attribute name.

Listing 2.7 DisplayAttributesServlet

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

public class ResponseDemoServlet implements Servlet {
  ServletConfig servletConfig; 

  public void init(ServletConfig config) throws ServletException {
    servletConfig = config; 
  } 

  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {

    ServletContext servletContext = servletConfig.getServletContext(); 
    Enumeration attributes = servletContext.getAttributeNames(); 
    while (attributes.hasMoreElements()) {
      String attribute = (String) attributes.nextElement(); 
      System.out.println("Attribute name : " + attribute); 
      System.out.println("Attribute value : " + 
        servletContext.getAttribute(attribute)); 
    } 
  } 

  public String getServletInfo() {
    return null; 
  } 
  public ServletConfig getServletConfig() {
    return null; 
  } 

}

Enumeration attributes = servletContext.getAttributeNames(); 
  while (attributes.hasMoreElements()) {
    String attribute = (String) attributes.nextElement(); 
    System.out.println("Attribute name : " + attribute); 
    System.out.println("Attribute value : " + 
      servletContext.getAttribute(attribute)); 
}

To see the servlets work, first you need to call the AttributeSetterServlet servlet to set the attribute "password". You then call the DisplayAttributesServlet to get an Enumeration of the names of all attributes and display the values.

The output is given here:

Attribute name : javax.servlet.context.tempdir 
Attribute value : C:\123data\JavaProjects\JavaWebBook\work\localhost_8080 
Attribute name : password 
Attribute value : dingdong 
Attribute name : sun.servlet.workdir 
Attribute value : C:\123data\JavaProjects\JavaWebBook\work\localhost_8080

The Servlet Context

2011-04-30T22:46:00.001+05:30

In servlet programming, the servlet context is the environment where the servlet runs. The servlet container creates a ServletContext object that you can use to access information about the servlet's environment.

A servlet also can bind an object attribute into the context by name. Any object bound into a context is available to any other servlet that is part of the same web application.

How do you obtain the ServletContext object? Indirectly, from the ServletConfig object passed by the servlet container to the servlet's init method. The ServletConfig interface has a method called getServletContext that returns the ServletContext object. You then can use the ServletContext interface's various methods to get the information you need. These methods include the following:

getMajorVersion. This method returns an integer representing the major version for the servlet API that the servlet container supports. If the servlet container supports the servlet API version 2.3, this method will return 2.
getMinorVersion. This method returns an integer representing the minor version of the servlet API that the servlet container supports. For the servlet API version 2.3, this method will return 3.
getAttributeNames. This method returns an enumeration of strings representing the names of the attributes currently stored in the ServletContext.
getAttribute. This method accepts a String containing the attribute name and returns the object bound to that name.
setAttribute. This method stores an object in the ServletContext and binds the object to the given name. If the name already exists in the ServletContext, the old bound object will be replaced by the object passed to this method.
removeAttribute. This method removes from the ServletContext the object bound to a name. The removeAttribute method accepts one argument: the name of the attribute to be removed.

The code in Listing 2.5 shows a servlet named ContextDemoServlet that retrieves some of the servlet context information, including attribute names and values, minor and major versions of the servlet container, and the server info.

Listing 2.5 Retrieving Servlet Context Information

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

public class ContextDemoServlet implements Servlet {
  ServletConfig servletConfig; 

  public void init(ServletConfig config) throws ServletException {
    servletConfig = config; 
  } 

  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {  
    ServletContext servletContext = servletConfig.getServletContext(); 
    Enumeration attributes = servletContext.getAttributeNames(); 
    while (attributes.hasMoreElements()) {
      String attribute = (String) attributes.nextElement(); 
      System.out.println("Attribute name : " + attribute); 
      System.out.println("Attribute value : " + 
        servletContext.getAttribute(attribute)); 
    } 

    System.out.println("Major version : " + 
servletContext.getMajorVersion()); 
    System.out.println("Minor version : " + 
servletContext.getMinorVersion()); 
    System.out.println("Server info : " + servletContext.getServerInfo()); 
  } 

  public String getServletInfo() {
    return null; 
  } 
  public ServletConfig getServletConfig() {
    return null; 
  } 

}

The output of the code is as follows. This output may be different on your computer, depending on the version of Tomcat you are using, the operating system, and so on.

Attribute name : javax.servlet.context.tempdirAttribute value : 
..\work\localhost\myApp 
Attribute name : org.apache.catalina.resources 
Attribute value : org.apache.naming.resources.ProxyDirContext@24e2e3 
Attribute name : org.apache.catalina.WELCOME_FILES 
Attribute value : [Ljava.lang.String;@2bb7e0 
Attribute name : org.apache.catalina.jsp_classpath 
Attribute value : C:\tomcat4\webapps\myApp\WEB-INF\classes; 
. 
. 
. Major version : 2Minor version : 3 
Server info : Apache Tomcat/4.0-b5

Preserving the ServletConfig

2011-04-30T22:45:00.001+05:30

The code in Listing 2.3 shows how you can use the ServletConfig object in the init method. Sometimes, however, you may want more flexibility. For example, you may want to have access to the ServletConfig object from the service method, when you are servicing the user. In this case, you need to preserve the ServletConfig object to a class level variable. This task is not difficult. You need to create a ServletConfig object variable and set it to the ServletConfig object returned by the servlet container in the init method.

Listing 2.4 gives the code that preserves the ServletConfig object for later use. First, you need a variable for the ServletConfig object.

ServletConfig servletConfig;

Then, in the init method, you write the following code:

servletConfig = config;

Now the servletConfig variable references the ServletConfig object returned by the servlet container. The getServletConfig method is provided to do just that: return the ServletConfig object.

public ServletConfig getServletConfig() {
  return servletConfig; 
}

If you extend the ReserveConfigServlet class, you can still retrieve the ServlerConfig object by calling the getServletConfig method.

Listing 2.4 Preserving the ServletConfig Object

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

public class ReserveConfigServlet implements Servlet {
  ServletConfig servletConfig; 

  public void init(ServletConfig config) throws ServletException {
    servletConfig = config; 
  } 

  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
  } 

  public String getServletInfo() {
    return null; 
  } 

  public ServletConfig getServletConfig() {
    return servletConfig; 
  } 

}

Obtaining Configuration Information

2011-04-30T22:44:00.001+05:30

The servlet specification allows you to configure your application. You'll find more information on this topic in the discussion of the deployment descriptor in Chapter 16, "Application Deployment." In this chapter, I present an example that demonstrates how you can retrieve configuration information from the application web.xml file.

For each servlet registered in the web.xml file, you have the option of specifying a set of initial parameter name/value pairs that you can retrieve from inside the servlet. The following web.xml file contains a servlet called ConfigDemo whose class is named ConfigDemoServlet.class. The servlet has two initial parameter name/value pairs. The first parameter is named adminEmail and its value is admin@brainysoftware.com. The second parameter is named adminContactNumber and the value for this parameter is 04298371237.

<?xml version="1.0" encoding="ISO-8859-1"?> 
<!DOCTYPE web-app 
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" 
    "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd"> 

<web-app> 
  <servlet> 
    <servlet-name>ConfigDemo</servlet-name> 
    <servlet-class>ConfigDemoServlet</servlet-class> 
    <init-param> 
      <param-name>adminEmail</param-name> 
      <param-value>admin@brainysoftware.com</param-value> 
    </init-param> 
    <init-param> 
      <param-name>adminContactNumber</param-name> 
      <param-value>04298371237</param-value> 
    </init-param> 
  </servlet> 
</web-app>

Why would you want to use an initial parameter? For practicality. Hardcoding information in the servlet code means that you have to recompile the servlet if the information changes. A web.xml file is plain text. You can edit its content easily using a text editor.

The code that retrieves the initial parameter name and values is given in Listing 2.3.

To retrieve initial parameters, you need the ServletConfig object passed by the servlet container to the servlet. After you get the ServletConfig object, you then can use its getInitParameterNames and getInitParameter methods. The getInitParameterNames does not take an argument and returns an Enumeration containing all the parameter names in the ServletConfig object. The getInitParameter takes a String containing the parameter name and returns a String containing the value of the parameter.

Because the servlet container passes a ServletConfig object to the init method, it is easiest to write the code in the init method. The code in Listing 2.3 loops through the Enumeration object called parameters that is returned from the getInitParameterNames method. For each parameter, it outputs the parameter name and value. The parameter value is retrieved using the getInitParameter method.

Listing 2.3 Retrieving Initial Parameters

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

public class ConfigDemoServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
    Enumeration parameters = config.getInitParameterNames(); 
    while (parameters.hasMoreElements()) {
      String parameter = (String) parameters.nextElement(); 
      System.out.println("Parameter name : " + parameter); 
      System.out.println("Parameter value : " + 
        config.getInitParameter(parameter)); 
    } 
  } 

  public void destroy() {
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
  } 

  public String getServletInfo() {
    return null; 
  } 

  public ServletConfig getServletConfig() {
    return null; 
  } 
}

The output of the code in the console is as follows:

Parameter name : adminContactNumber 
Parameter value : 04298371237 
Parameter name : adminEmail 
Parameter value : admin@brainysoftware.com

Demonstrating the Life Cycle of a Servlet

2011-04-30T22:43:00.001+05:30

Listing 2.1 contains the code for a servlet named PrimitiveServlet, a very simple servlet that exists to demonstrate the life cycle of a servlet. The PrimitiveServlet class implements javax.servlet.Servlet (as all servlets must) and provides implementations for all the five methods of servlet. What it does is very simple. Each time any of the init, service, or destroy methods is called, the servlet writes the method's name to the console.

Listing 2.1 PrimitiveServlet.java

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

public class PrimitiveServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
    System.out.println("init"); 
  } 

  public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
    System.out.println("service"); 
  }   
  public void destroy() {
    System.out.println("destroy"); 
  } 

  public String getServletInfo() {
    return null; 
  } 
  public ServletConfig getServletConfig() {
    return null; 
  } 

}

After you compile the source code into the myApp\WEB-INF\classes directory, add the servlet to the web.xml under the name Primitive, as shown in Listing 2.2.

Listing 2.2 The web.xml File for PrimitiveServlet

<?xml version="1.0" encoding="ISO-8859-1"?> 

<!DOCTYPE web-app 
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" 
  "http://java.sun.com/dtd/web-app_2_3.dtd"> 

<web-app> 
  <servlet> 
    <servlet-name>Primitive</servlet-name> 
    <servlet-class>PrimitiveServlet</servlet-class> 
  </servlet> 
</web-app>

You should then be able to call this servlet from your browser by typing the following URL:

http://localhost:8080/myApp/servlet/Primitive

The first time the servlet is called, the console displays these two lines:

init 
service

This tells you that the init method is called, followed by the service method. However, on subsequent requests, only the service method is called. The servlet adds the following line to the console:

service

This proves that the init method is called only once.

What are the getServletInfo and getServletConfig doing in Listing 2.1 ? Nothing. They can be useful, but in the PrimitiveServlet class, they are just there to meet the specification that a class must provide implementations for all methods in the interface it implements.

You can return any string in the getServletInfo method, such as your company name or the author name or other information deemed necessary. Other people might extend your servlet class and might want to know what useful information the designer of the servlet has provided.

The getServletConfig is more important. We will see how it can be of use next

A Servlet's Life Cycle

2011-04-30T22:42:00.001+05:30

Let there be servlet. This interface in the javax.servlet package is the source of all activities in servlet programming. Servlet is the central abstraction of the Java servlet technology. Every servlet you write must implement this javax.servlet.Servlet interface, either directly or indirectly. The life cycle of a servlet is determined by three of its methods: init, service, and destroy.

The init( ) Method

The init method is called by the servlet container after the servlet class has been instantiated. The servlet container calls this method exactly once to indicate to the servlet that the servlet is being placed into service. The init method must complete successfully before the servlet can receive any requests.

You can override this method to write initialization code that needs to run only once, such as loading a database driver, initializing values, and so on. In other cases, you normally leave this method blank.

The signature of this method is as follows:

public void init(ServletConfig config) throws ServletException

The init method is important also because the servlet container passes a ServletConfig object, which contains the configuration values stated in the web.xml file for this application. More on ServletConfig can be found later in this chapter, in the section, "Obtaining Configuration Information."

This method also can throw a ServletException. The servlet container cannot place the servlet into service if the init method throws a ServletException or the method does not return within a time period defined by the web server.

Note

ServletException is the most important exception in servlet programming. In fact, a lot of methods in the javax.servlet and javax.servlet.http packages can throw this exception when a problem exists in a servlet.

The service( ) Method

The service method is called by the servlet container after the servlet's init method to allow the servlet to respond to a request.

Servlets typically run inside multithreaded servlet containers that can handle multiple requests concurrently. Therefore, you must be aware to synchronize access to any shared resources, such as files, network connections, and the servlet's class and instance variables. For example, if you open a file and write to that file from a servlet, you need to remember that a different thread of the same servlet also can open the same file. See the section, "Creating Thread-Safe Servlets," for more on the topic of multithreading and synchronization.

This method has the following signature:

public void service(ServletRequest request, ServletResponse response) 
  throws ServletException, java.io.IOException

The servlet container passes a ServletRequest object and the ServletResponse object. The ServletRequest object contains the client's request and the ServletResponse contains the servlet's response. These two objects are important because they enable you to write custom code that determines how the servlet services the client request.

The service method throws a ServletException if an exception occurs that interferes with the servlet's normal operation. The service method also can throw a java.io.IOException if an input or output exception occurs during the execution of this method.

As the name implies, the service method exists so that you can write code that makes the servlet function the way it is supposed to.

The destroy( ) Method

The servlet container calls the destroy method before removing a servlet instance from service. This normally happens when the servlet container is shut down or the servlet container needs some free memory.

This method is called only after all threads within the servlet's service method have exited or after a timeout period has passed. After the servlet container calls this method, it will not call the service method again on this servlet.

The destroy method gives the servlet an opportunity to clean up any resources that are being held (for example, memory, file handles, and threads) and make sure that any persistent state is synchronized with the servlet's current state in memory.

The signature of this method is as follows:

public void destroy()

The javax.servlet Package

2011-04-30T22:39:00.001+05:30

The javax.servlet package contains seven interfaces, three classes, and two exceptions. Instead of using the conventional approach by explaining each interface and class in alphabetical order—thus making the book feel like a dictionary—I present the discussions based on functions and offer examples that demonstrate each function.

Nevertheless, mastering all the members of this package is important. To help you, a complete reference is given in Appendix B, "The javax.servlet Package Reference."

The seven interfaces are as follows:

The three classes are as follows:

And, finally, the exception classes are these:

The object model of the javax.servlet package is shown in Figure 2.1.

Figure 2.1. The javax.servlet package object model.

Inside Servlets

2011-04-30T22:38:00.001+05:30

Watching your servlet in action, as you did in Chapter 1, "The Servlet Technology," should bring you confidence. And, as some people say, having confidence is half the battle in learning anything. To be an expert, however, you need to understand the nuts and bolts of the Java Servlet specification Application Programming Interface (API). This book has been written using the latest release of the servlet specification API—version 2.3. Two packages are available for servlet programmers: javax.servlet and javax.servlet.http. The first one contains basic classes and interfaces that you can use to write servlets from the scratch. The second package, javax.servlet.http, offers more advanced classes and interfaces that extend classes and interfaces from the first package. It is much more convenient to program using the second package.

When you learn something, it is best to start with the basics and build a strong foundation. For example, understanding the javax.servlet.Servlet interface is very important because it encapsulates the life cycle methods of a servlet and it is the interface that all servlets must implement. You also need to know the servlet's context, which represents a servlet's environment, and the servlet's configuration. Because of the importance of these items, this chapter introduces you to members of the javax.servlet package. In this chapter, you also will see that oftentimes several ways exist to do the same thing.

After a few examples, I will introduce you to the GenericServlet class, a member of the javax.servlet package that acts as a wrapper for the javax.servlet.Servlet interface. Extending this class makes your code simpler because you need to provide implementations only for methods that you need to use.

To run each example in this chapter, you need to compile the source code and copy the resulting class file into the classes directory under the WEB-INF directory of your application. Refer to Chapter 1 if you have forgotten the six steps you need to run your servlet.

The rest of this chapter explains and uses the interfaces and classes of the javax.servlet package. The chapters that follow focus more on the second package

Six Steps to Running Your First Servlet

2011-04-30T22:32:00.001+05:30

After you have installed and configured Tomcat, you can put it into service. Basically, you need to follow six steps to go from writing your servlet to running it. These steps are summarized as follows:

Create a directory structure under Tomcat for your application.
Write the servlet source code. You need to import the javax.servlet package and the javax.servlet.http package in your source file.
Compile your source code.
Create a deployment descriptor.
Run Tomcat.
Call your servlet from a web browser.

The sections that follow walk you through each of these steps.

Step 1: Create a Directory Structure Under Tomcat

Note

The directory where Tomcat is installed is often referred to as %CATALINA_HOME%. In previous versions of Tomcat, this directory was called %TOMCAT_HOME%.

When you install Tomcat, several subdirectories are automatically created under the Tomcat home directory (%CATALINA_HOME%). One of the subdirectories is webapps. The webapps directory is where you store your web applications. A web application is a collection of servlets and other content installed under a specific subset of the server's URL namespace. A separate directory is dedicated for each servlet application. Therefore, the first thing to do when you build a servlet application is create an application directory. To create a directory structure for an application called myApp, follow these steps:

Create a directory called myApp under the webapps directory. The directory name is important because this also appears in the URL to your servlet.
Create the and WEB-INF directories under myApp, and create a directory named classes under WEB-INF. The directory structure is shown in Figure 1.4. The directory classes under WEB-INF is for your Java classes. If you have HTML files, put them directly under the myApp directory. You may also want to create a directory called images under myApp for all your image files.

Figure 1.4. Tomcat application directory structure.

Note that the examples, manager, ROOT, tomcat-doc, and webdav directories are for applications that are created automatically when you install Tomcat.

Step 2: Write the Servlet Source Code

In this step, you prepare your source code. You can write the source code yourself using your favorite text editor or copy it from the accompanying CD.

Tip

The source code for all examples in this book are also available on the book's web site. Check out www.newriders.com to download the files you need.

The code in Listing 1.1 shows a simple servlet called TestingServlet. The file is named TestingServlet.java. The servlet sends a few HTML tags and some text to the browser. For now, don't worry if you haven't got a clue about how it works.

Listing 1.1 TestingServlet.java

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

public class TestingServlet extends HttpServlet {

  public void doGet(HttpServletRequest request, 
    HttpServletResponse response) 
    throws ServletException, IOException {

    PrintWriter out = response.getWriter(); 
    out.println("<HTML>"); 
    out.println("<HEAD>"); 
    out.println("<TITLE>Servlet Testing</TITLE>"); 
    out.println("</HEAD>"); 
    out.println("<BODY>"); 
    out.println("Welcome to the Servlet Testing Center"); 
    out.println("</BODY>"); 
    out.println("</HTML>"); 
  } 
}

Now, save your TestingServlet.java file to the WEB-INF/classes directory under myApp. Placing your source code here will make it inaccessible from a web browser. Static files, such as HTML files and image files, should be placed directly under the myApp directory or a directory under it.

Warning

Placing your source code files outside the WEB-INF directory will make them viewable from a browser.

Step 3: Compile Your Source Code

For your servlet source code to compile, you need to include the path to the servlet.jar file in your CLASSPATH environment variable. The servlet.jar is located in the common\lib\ subdirectory under %CATALINA_HOME%.

For example, if you installed Tomcat under the C:\drive on Windows and you named the install directory tomcat, type the following command from the directory where TestingServlet.java resides.

javac classpath C:\tomcat\common\lib\servlet.jar TestingServlet.java

Alternatively, to save you typing the class path every time you compile your source code, you can add the complete path to the servlet.jar file to your CLASSPATH environment variable. Again, if you have installed Tomcat under C:\and named the install directory tomcat, you must add C:\tomcat\ common\lib\servlet.jar to the CLASSPATH environment variable. Afterward, you can compile your source by simply typing the following.

javac TestingServlet.java

Note

If you have forgotten how to edit the CLASSPATH environment variable, refer to Appendix A.

If you are using Windows, remember that the new environment variable takes effect only for new console windows. In other words, after changing a new environment variable, open a new console window for typing in your command lines.

Step 4: Create the Deployment Descriptor

A deployment descriptor is an optional component in a servlet application. The descriptor takes the form of an XML document called web.xml and must be located in the WEB-INF directory of the servlet application. When present, the deployment descriptor contains configuration settings specific to that application. Deployment descriptors are discussed in detail in Chapter 16.

To create the deployment descriptor, you now need to create a web.xml file and place it under the WEB-INF directory under myApp.

The web.xml for this example application must have the following content.

<?xml version="1.0" encoding="ISO-8859-1"?> 

<!DOCTYPE web-app 
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" 
  "http://java.sun.com/dtd/web-app_2_3.dtd"> 

<web-app> 
  <servlet> 
    <servlet-name>Testing</servlet-name> 
    <servlet-class>TestingServlet</servlet-class> 
  </servlet> 
</web-app>

The web.xml file has one element—web-app. You should write all your servlets under <web-app>. For each servlet, you have a <servlet> element and you need the <servlet-name> and <servlet-class> elements. The <servlet-name> is the name for your servlet, by which it is known Tomcat. The <servlet-class> is the compiled file of your servlet without the .class extension.

Having more than one servlet in an application is very common. For every servlet, you need a <servlet> element in the web.xml file. For example, the following shows you how web.xml looks if you add another servlet called Login:

<?xml version="1.0" encoding="ISO-8859-1"?> 

<!DOCTYPE web-app 
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" 
  "http://java.sun.com/dtd/web-app_2_3.dtd"> 

<web-app> 
  <servlet> 
    <servlet-name>Testing</servlet-name> 
    <servlet-class>TestingServlet</servlet-class> 
  </servlet> 
  <servlet> 
    <servlet-name>Login</servlet-name> 
    <servlet-class>LoginServlet</servlet-class> 
  </servlet> 
</web-app>

Step 5: Run Tomcat

If Tomcat is not already running, you need to start it. See Appendix A for information on how to start or run Tomcat.

Step 6: Call Your Servlet from a Web Browser

Now, you can call your servlet from a web browser. By default, Tomcat runs on port 8080 in the myApp virtual directory under the servlet subdirectory. The servlet that you wrote in the preceding steps is named Testing. The URL for that servlet has the following format:

http://domain-name/virtual-directory/servlet/servlet-name

Any static file can be accessed using the following URL:

http://domain-name/virtual-directory/staticFile.html

For example, a Logo.gif file under the myApp/images/ directory can be accessed using the following URL.

http://domain-name/virtual-directory/images/Logo.gif

If you run the web browser from the same computer as Tomcat, you can replace the domain-name part with "localhost". In that case, the URL for your servlet is

http://localhost:8080/myApp/servlet/Testing

In the deployment descriptor you wrote in Step 4, you actually mapped the servlet class file called TestingServlet with the name "Testing," so that your servlet can be called by specifying its class file (TestingServlet) or its name (Testing). Without a deployment descriptor, you must call the servlet by specifying its class name; that is, TestingServlet. This means that if you did not write a deployment descriptor in Step 4, you need to use the following URL to call your servlet:

http://localhost:8080/myApp/servlet/TestingServlet

Typing the URL in the Address or Location box of your web browser will give you the string "Welcome to the Servlet Testing Center," as shown in Figure 1.5.

Figure 1.5. The Testing servlet.

Congratulations. You have just written your first servlet.

If you don't want to type the port number each time, you can change the default port of Tomcat so that it runs on port 80, the default port for a web server. (Details on how to change the port number can be found in Appendix A.) However, the rest of the book will use Tomcat's default port 8080.

Note

You will find code for various servlets in this chapter and the next. To run each individual servlet, you need to repeat these six steps. To avoid repetition, I do not mention these steps for every servlet presented in this book. You don't need to worry about these steps if you are using a Java development tool, such as Borland's JBuilder or IBM's VisualAge, because those steps are taken care of by the RAD program.

The Tomcat Servlet Container

2011-04-30T22:31:00.001+05:30

A number of servlet containers are available today. The most popular one—and the one recognized as the official servlet/JSP container—is Tomcat. Originally designed by Sun Microsystems, Tomcat source code was handed over to the Apache Software Foundation in October 1999. In this new home, Tomcat was included as part of the Jakarta Project, one of the projects of the Apache Software Foundation. Working through the Apache process, Apache, Sun, and other companies—with the help of volunteer programmers worldwide—turned Tomcat into a world-class servlet reference implementation. Two months after the handover, Tomcat version 3.0 was released. Tomcat went through several 3.x releases until version 3.3 was introduced.

The successor of version 3.3 is the current version, version 4.0. The 4.0 servlet container (Catalina) is based on a completely new architecture and has been developed from the ground up for flexibility and performance. Version 4.0 implements the Servlet 2.3 and JSP 1.2 specifications, and it is this version you will be using in this book.

Another popular servlet container is JRun from Allaire Corporation. JRun is available in three editions: Developer, Professional, and Enterprise. The Developer edition is free but not licensed for deployment. The Professional and Enterprise editions grant you the license for deployment with a fee. You can download JRun from http://commerce.allaire.com/download.

Tomcat by itself is a web server. This means that you can use Tomcat to service HTTP requests for servlets, as well as static files (HTML, image files, and so on). In practice, however, since it is faster for non-servlet, non-JSP requests, Tomcat normally is used as a module with another more robust web server, such as Apache web server or Microsoft Internet Information Server. Only requests for servlets or JSP pages are passed to Tomcat.

To write a servlet, you need at least version 1.2 of the Java Development Kit. If you have not already downloaded one, you can download JDK 1.2 from http://java.sun.com/j2se. The reference implementation for both servlets and JSP are not included in J2SE, but they are included in Tomcat. Tomcat is written purely in Java.

If you haven't yet installed and configured Tomcat, now's the time to do it. If you need help with these tasks, refer to Appendix A for specific steps.

How a Servlet Works

2011-04-30T22:27:00.001+05:30

A servlet is loaded by the servlet container the first time the servlet is requested. The servlet then is forwarded the user request, processes it, and returns the response to the servlet container, which in turn sends the response back to the user. After that, the servlet stays in memory waiting for other requests—it will not be unloaded from the memory unless the servlet container sees a shortage of memory. Each time the servlet is requested, however, the servlet container compares the timestamp of the loaded servlet with the servlet class file. If the class file timestamp is more recent, the servlet is reloaded into memory. This way, you don't need to restart the servlet container every time you update your servlet.

The way in which a servlet works inside the servlet container is depicted in the diagram in Figure 1.3.

Figure 1.3. How a servlet works.

Servlet Application Architecture

2011-04-30T22:25:00.003+05:30

A servlet is a Java class that can be loaded dynamically into and run by a special web server. This servlet-aware web server is called a servlet container, which also was called a servlet engine in the early days of the servlet technology.

Servlets interact with clients via a request-response model based on HTTP. Because servlet technology works on top of HTTP, a servlet container must support HTTP as the protocol for client requests and server responses. However, a servlet container also can support similar protocols, such as HTTPS (HTTP over SSL) for secure transactions.

Figure 1.1 provides the architecture of a servlet application.

Figure 1.1. The servlet application architecture.

In a JSP application, the servlet container is replaced by a JSP container. Both the servlet container and the JSP container often are referred to as the web container or servlet/JSP container, especially if a web application consists of both servlets and JSP pages.

Note

You will learn more about servlet and JSP containers in Chapter 8, "JSP Basics.

As you can see in the Figure 1.1, a servlet application also can include static content, such as HTML pages and image files. Allowing the servlet container to serve static content is not preferable because the content is faster if served by a more robust HTTP server, such as the Apache web server or Microsoft Internet Information Server. As such, it is common practice to put a web server at the front to handle all client requests. The web server serves static content and passes to the servlet containers all client requests for servlets. Figure 1.2 shows a more common architecture for a servlet application.

Figure 1.2. The servlet application architecture employing an HTTP server.

Caution

A Java web application architecture employing a J2EE server is different from the diagrams in Figures 1.1 and 1.2. This is discussed in Chapter 28, "Enterprise JavaBeans."

Listing 3: package event

2011-04-30T00:29:00.000+05:30

Listing 3:
package event;

import com.sun.java.swing.event.EventListenerList;
import java.io.Serializable;

/**
* Abstract class that both consumes events and
* forwards event to other consumers.
* Generally used to filter the events by their
* context and possibly some other data, so that
* the other consumers get only the events they
* are interested in.
* The consume method needs to be implemented.
*/

public abstract class EventFilter implements
   EventConsumer, EventDistributor, Serializable
{
  private EventListenerList myEventConsumer = null;

  /**
   * Constructor.
   */
  public EventFilter () {
   myEventConsumer = new EventListenerList();
  }

  /**
   * Abstract method that processes Events.
   * This method needs to be implmented to
   * process each event when they are received.
   * @param Event the event to be processed.
   * @see EventConsumer.
   */
  public abstract void consume(Event event);

  /**
   * Add an event consumer.
   * @see EventDistributor.
   */
  public void addEventConsumer(
   EventConsumer consumer, String context)
  {
   myEventConsumer.add(EventConsumer.class,
   consumer);
  }

  /**
   * Remove an event consumer.
   * @see EventDistributor.
   */
  public void removeEventConsumer(
   EventConsumer consumer)
  {
   myEventConsumer.remove(EventConsumer.class,
   consumer);
  }

  /**
   * Call all consumers that have registered.
   * Helper method to walk the list of consumers
   * calling all of their consume methods.
   * @param Event the event to be processed.
   * @see EventListenerList
   */
  protected void fireEventConsumer(Event newEvent)
  {
   Object[] listeners =
   myEventConsumer.getListenerList();

   for (int i = listeners.length-2;
   i >= 0;
   i -= 2)
   {
   if (listeners[i] == EventConsumer.class) {
   ((EventConsumer)
   listeners[i+1]).consume(newEvent);
   }
   }
  }
}

Listing 2: package event

2011-04-30T00:28:00.000+05:30

Listing 2:
package event;

/**
* The interface used by any component that
* distributes events to other consumers.
*/
public interface EventDistributor {
  /**
   * Add an Event Consumer to the existing set of
   * event consumers that will be called when an
   * event of the proper type is recieved.
   * @param EventConsumer the consumer to be
   * added.
   * @param String the context in which the event
   * consumer wants to be called.
   */
  public void addEventConsumer(EventConsumer cons,
   String context);

  /**
   * Remove an Event Consumer from the existing
   * set of event consumers that will be called
   * when an event is processed.
   * @param EventConsumer the consumer to be
   * removed.
   */
  public void removeEventConsumer(EventConsumer c);
}

package event Listing 1

2011-04-30T00:27:00.000+05:30

Listing 1:
package event;

import java.util.EventListener;
import java.io.Serializable;

/**
* Interface for anything that will consume events.
*/

public interface EventConsumer
   extends EventListener
  {

  /**
   * Consume method processes events of interest.
   * @param Event the event.
   */
  public void consume(Event event);
}

Equals

2011-04-07T09:29:00.000+05:30

public class Equals{
public static void main(String args[]){
    Calculator c1=new Calculator();
    Calculator c2=c1;//new Calculator();
    if(c1==c2){
       System.out.println("c1==c2");
    }else{
    System.out.println("c1!=c2");
    }
    if(c1.equals(c2)){
       System.out.println("c1.equals(c2)");
    }else{
    System.out.println(" c1 not equal to (c2)");
    }
}
}

DEMO

2011-04-07T09:28:00.000+05:30

class Math{
public static void main(String args[]){

/*    if(c1==c2){
       System.out.println("c1==c2");
    }else{
    System.out.println("c1!=c2");
    }
    if(c1.equals(c2)){
       System.out.println("c1.equals(c2)");
    }else{
    System.out.println(" c1 not equal to (c2)");
    }
*/
}
}

Calculator

2011-04-07T09:26:00.002+05:30

public class Calculator
{
public int add(int x,int y){
        System.out.println("From Add");
        return x+y;
    }
    public int div(int x,int y){
        System.out.println("From div");
        return x/y;
    }
    public int product(int x,int y){
        System.out.println("From product");
        return x*y;


}
}

Designing Of An Effective Resume

2011-03-23T09:18:00.000+05:30

‘Curriculum-Vitae’ (C.V for short) is a brief account of your personal details, educational and professional qualifications and the jobs you have held. T is a British expression. The American term for the same is ‘Resume’.

What should a C.V Do?

- It must highlight your potential and value to an employer.

- Provide a framework with which an interview can be designed.

- Provide a vivid account of your achievements as a student and as a professional along with the skills you would bring to an organization, in case you are hired.

- Although a C.V never ensures an employment, it should at least arouse the employer’s interest and get you an interview call.

Lay out of a C.V

An effective C.V should be visually appealing. That means it should appear neat and orderly. It should beclear, concise and easy to read. The way, in which the information is presented on paper, goes a long way in creating a favorable first impression.

Things to Remember

1. Make sure that you use very good quality paper for your C.V and the covering letter that goes with it.

2. Leave clear margins and be consistent while presenting your information.

3. It should be typed neatly.

4. Be brief and to the point. Do not use ‘ten’ words where ‘five’ will do. However substance should not be sacrificed for the sake of ‘brevity’. Right attributes and achievements should be mentioned and emphasized properly. It is important to present yourself as a valuable candidate for the job advertised.

5. It is advisable to show the finished product to someone well meaning and knowledgeable. Be prepared to incorporate suggestions and changes if they enhance the quality of your C.V.

6. Never give false information.

7. It is of utmost importance to understand the job requirements and your suitability for the post.

8. Highlight areas, where you can contribute fruitfully and effectively, rather than harping on your aspirations.
Key Components of a C.V

Given below are the main constituents of a Resume.

The Information given hereunder need not appear in the same order. Freshers and students may use the same sequence but working professionals may rearrange it to suit their preference and requirements.

1. Personal Details

•   Full Name
•   Age/Date of Birth
•   Place of Birth
•   Sex/Gender (Male/Female)
•   Address for Correspondence
•   Telephone Numbers (Landline/Mobile)
•   Nationality (In case of overseas employment)
•   Passport Number.               –Do-
•   Driving License Number
•   Health (Unless some serious ailment, it should be stated as sound/excellent)
•   Personal Hobbies and Interests
•   Preferred Location

2. Educational and Professional Qualifications

Note: – You may mention here your professional qualifications or your occupation. For example: Computer Engineer, Law Graduate, Chartered Accountant etc.

Educational qualifications can be mentioned in the form of a table given below: -

Examination Year University Percentage Class/Div.

It may be written in the descending order, i.e. from the highest degree to the S.S.C examination or in the ascending order, i.e. beginning from the secondary education to the highest qualification acquired by you. Below secondary level education is not to be mentioned.

Any additional training, diplomas and special courses undertaken must find place after the main educational details have been given.

3. Career History

It is the most crucial information for the employer. If you are already employed or are looking for a change, you must provide information regarding the jobs you have held. Your present assignment, the work experience you have gathered, the responsibilities you have shouldered and the skills developed during the work span, all have to be mentioned here. You may have the best of qualifications but your hands on experience in the relevant field are of greater value to the employer.

POINTS TO REMEMBER

1. You should always catalog your jobs in the reverse order. Begin with your present employment or the most recent one, as it is of greatest interest to the prospective employer.

2. Avoid the use of first person, if possible.

•   Work experience described under headings such as:
•   Period ——–From——-To—–
•   Employer——Name of the Organization
•   Designation————–
•   Reporting To——-Name of the immediate Boss—-

And a Work Profile given as mentioned below: -
•   To assist the Departmental Head
•   Time to time maintenance of electrical machines
•   Trouble-shooting problems arising in the shop floor machines etc.
Is not only more appealing; it gives a clear idea of the person’s work and responsibilities at a quick glance.

3. The information should be so organized in this section that it gives a clear idea of your strengths to the prospective employer.

4. In case you have undertaken a number of similar jobs, enlist them under one section, if possible.

5. Salary: – It is advisable not to mention salary at this point. At most an expected salary range can be mentioned.

6. References – These must be provided if asked by the employer. But you must seek permission from the persons whose names have been given as referees.

CONCLUSION

Suggested above is the basic structure of curriculum vitae. There can be several variants of the above-mentioned information. One may reorganize various headings, choosing to begin with very little personal details and devoting more space to the career history and educational qualifications, one’s career objectives, work ethics, specialized skills etc.

Actually for an experienced professional these elements should be highlighted and mentioned first of all, immediately after ‘The Name of the Person’. Other details can be given in the end.

If you are a fresher and have no work experience to mention, then lay emphasis on your educational qualifications or any other achievements during the school and campus life.

The idea is, to present a well-rounded picture of yourself and the valuable differences you can make to the organization, you seek to join.

Servlet initialisation parameters

2011-03-12T10:58:00.001+05:30

package com.ack.web.servlet;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Enumeration;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

* initialisation parameters inside the web.xml file

<servlet-name>initialisation</servlet-name>

<servlet-class>com.ack.web.servlet.ServletInitialisationParameters</servlet-class>

<init-param>

<param-name>jdbcurl</param-name>

<param-value>someurl</param-value>

</init-param>

<init-param>

<param-name>password</param-name>

<param-value>bah</param-value>

</init-param>

<init-param>

<param-name>username</param-name>

<param-value>foo</param-value>

</init-param>

</servlet>

public class ServletInitialisationParameters extends HttpServlet {

public void init() throws ServletException {

String jdbcURL = getInitParameter( "jdbcurl" );

String username = getInitParameter( "username" );

String password = getInitParameter( "password" );

try {

if( jdbcURL == null || username == null || password == null ) {

StringBuffer buf = new StringBuffer( "you must specify the " );

buf.append( " 'jdbcurl', 'username', 'password' init params to -> " );

buf.append( getClass().getName() + " within you web.xml file" );

String msg = buf.toString();

System.out.println( buf );

// log( msg );

// throw new ServletException( msg );

}

else {

// possible get connection to database

}

catch( Exception ex ) {

log( ex.toString() );

throw new ServletException( ex.toString() );

}

finally {

// do any clean-up if you need to

}

log( "Completed Initialisation ->" + getClass().getName() );

}

public void doGet( HttpServletRequest req, HttpServletResponse res )

throws ServletException, IOException {

res.setContentType( "text/html" );

PrintWriter pw = res.getWriter();

pw.println( "<h3>Servlet Initialisation Parameters</h3>" );

pw.println( "<p><hr noshade><p>" );

Enumeration e = getInitParameterNames();

while( e.hasMoreElements() ) {

String paramName = (String) e.nextElement();

pw.println( "Initialisation Parameter: [ " );

pw.println( paramName + " = " + getInitParameter( paramName ) );

pw.println( " ]<br>" );

}

Projects Free With Source Code

Popup Button

Creating Thread-Safe Servlets

Figure 2.6. Understanding multi-threaded code.

Listing 2.13 Unsafe Multi-Threaded Servlet

Listing 2.14 Safe Multi-Threaded Servlet

Listing 2.15 Demonstrating an Unsafe Multi-Threaded Servlet

The GenericServlet Wrapper Class

Listing 2.12 Extending GenericServlet

Figure 2.5. Extending GenericServlet.

The ServletResponse Interface

Listing 2.10 index2.html

Listing 2.11 The ResponseDemoServlet

Figure 2.3. The index2.html file.

Figure 2.4. Utilizing the ServletResponse object.

The ServletRequest Interface

The ServletRequest Interface

Listing 2.8 index.html

Listing 2.9 RequestDemoServlet

Figure 2.2. The index.html file.

Sharing Information Among Servlets

Listing 2.6 The AttributeSetterServlet

Listing 2.7 DisplayAttributesServlet

The Servlet Context

Listing 2.5 Retrieving Servlet Context Information

Preserving the ServletConfig

Listing 2.4 Preserving the ServletConfig Object

Obtaining Configuration Information

Listing 2.3 Retrieving Initial Parameters

Demonstrating the Life Cycle of a Servlet

Listing 2.1 PrimitiveServlet.java

Listing 2.2 The web.xml File for PrimitiveServlet

A Servlet's Life Cycle

The init( ) Method

The service( ) Method

The destroy( ) Method

The javax.servlet Package

Figure 2.1. The javax.servlet package object model.

Inside Servlets

Six Steps to Running Your First Servlet

Step 1: Create a Directory Structure Under Tomcat

Figure 1.4. Tomcat application directory structure.

Step 2: Write the Servlet Source Code

Listing 1.1 TestingServlet.java

Step 3: Compile Your Source Code

Step 4: Create the Deployment Descriptor

Step 5: Run Tomcat

Step 6: Call Your Servlet from a Web Browser

Figure 1.5. The Testing servlet.

The Tomcat Servlet Container

How a Servlet Works

Figure 1.3. How a servlet works.

Servlet Application Architecture

Figure 1.1. The servlet application architecture.

Figure 1.2. The servlet application architecture employing an HTTP server.

Listing 3: package event

Listing 2: package event

package event Listing 1

Equals

DEMO

Calculator

Designing Of An Effective Resume

Servlet initialisation parameters