The second JSP is the target JSP referenced by the servlet defined in the following section. This JSP will retrieve the request attribute USER that was added to the request with the following servlet. It will then output the String value of the attribute. Listing 3 contains the source for the target JSP.

Listing 3 welcome.jsp

 
 


 
  
   
  
  
  
  
  
  
   
  
 

	Welcome : <%= request.getAttribute("USER") %>

As we stated earlier to deploy this JSP, you simply need to copy it to the public directory of your web application, which in this case is TOMCAT_HOME/webapps/onjava/.

Adding Servlets

The next component to add is a servlet. This servlet will be the action of login.jsp's form. It will retrieve the username and password values from HttpServletRequest, look up the associated user, and then forward the request to a target JSP. The source code for this servlet can be found in Listing 4.

For our example the value of the USER is static. Normally you would perform a real lookup of some sort, but, to keep things simple, I'm just returning String Bob.

Listing 4 com.onjava.login.java

package com.onjava;

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

public class login extends HttpServlet {

 private String target = "/welcome.jsp";

 private String getUser(String username, String password) {

// Just return a static name
  // If this was reality, we would perform a SQL lookup
  return "Bob";
 }

 public void init(ServletConfig config)
  throws ServletException {

  super.init(config);
 }

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

  // If it is a get request forward to doPost()
  doPost(request, response);
 }

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

  // Get the username from the request
  String username = request.getParameter("username");
  // Get the password from the request
  String password = request.getParameter("password");

  String user = getUser(username, password);

  // Add the fake user to the request
  request.setAttribute("USER", user);

  // Forward the request to the target named
  ServletContext context = getServletContext();

  RequestDispatcher dispatcher =
   context.getRequestDispatcher(target);
  dispatcher.forward(request, response);
 }

 public void destroy() {
 }
}

To deploy a servlet as part of a web application you first need to compile the servlet and move it into the web application's /WEB-INF/classes directory. For this example, you should compile this servlet and move it to the /onjava/WEB-INF/classes/com/onjava/ directory.

This class file is in the subdirectory com.onjava because of its package name.

The next step in deploying the login servlet is to add a servlet entry into the web application's web.xml file. An example element can be found in the following code snippet.

It isn't necessary to add all servlets to the web.xml file; it's only necessary when the servlet requires additional information, such as initialization parameters.

Example Element


  ExampleServlet
  packagename.ExampleServlet
  
   parameter
   value
  
  1


This servlet entry contains a simple servlet definition. A description of each of its parts can be found in Table 2.

To add our login servlet we need to make the following entry into the TOMCAT_ROOT/onjava/WEB-INF/web.xml file:


login
com.onjava.login


That's all there is to it. To see your web application in action, restart the Tomcat server and open the following URL in your browser:

http://localhost:8080/onjava/login.jsp

Adding Tag Libraries

The final component that we're adding is a tag library. This library contains a single tag, HelloTag, that replaces every occurrence of the text with the literal string "Hello". While this is a perfectly silly example of a tag library, it allows us to present a practical example of deploying a tag library. The source code for the tag handler can be found in Listing 5 and the source for the tld can be found in Listing 6.

Listing 5 HelloTag.java

package com.onjava;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;

public class HelloTag extends TagSupport
{
 public void HelloTag() {

 }

 // Method called when the closing hello tag is encountered
 public int doEndTag() throws JspException {

  try {

   // We use the pageContext to get a Writer
   // We then print the text string Hello
   pageContext.getOut().print("Hello");
  }
  catch (Exception e) {

   throw new JspTagException(e.getMessage());
  }
  // We want to return SKIP_BODY because this Tag does not support
  // a Tag Body
  return SKIP_BODY;
 }

 public void release() {

  // Call the parent's release to release any resources
  // used by the parent tag.
  // This is just good practice for when you start creating
  // hierarchies of tags.
  super.release();
 }
}

Listing 6 taglib.tld


  PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">




 1.0
 1.1
 onjava
 /onjava

 
 hello
 com.onjava.HelloTag
 empty
 Just Says Hello
 


To deploy this tag library, we need to make an entry to the web.xml file. The modified web.xml file can be found in Listing 7.

Listing 7 web.xml



 '-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN'
 'http://java.sun.com/j2ee/dtds/web-app_2_3.dtd'>



 
  login
  com.onjava.login
 

 
  /onjava
  /WEB-INF/lib/taglib.tld
 



The added entry contains two elements. The first element, , tells the container how the tag library is to be referenced. For this example we use the value /onjava, which is the way we'll reference the tag library in our JSPs.

The second element, , defines the location of the tag library's descriptor (TLD). The TLD defines the tags contained in the library and the handlers that will process the defined tags.

To complete your deployment, copy the compiled tag library and the taglib.tld into the TOMCAT_ROOT/onjava/WEB-INF/lib directory.

To test you new tag library, you need to modify the welcome.jsp page, replacing the Welcome message with a reference to the tag. You need to also add a taglib directive referencing the taglib.tld to the welcome.jsp file. The modified JSP is in Listing 7.

Listing 7 Modified welcome.jsp

<%@ taglib uri="/onjava" prefix="onjava" %>


 
 


 
  
   
  
  
  
  
  
  
   
  
 

	: <%= request.getAttribute("USER") %>

Now open the login.jsp page as described previously and run through the demo again. This time instead of Welcome: Bob, you should see the message Hello: Bob.

Creating and Deploying a WAR File

When your web application is ready for deployment, you need to package it for distribution. As we discussed previously in Java Web Applications, web applications are packaged in WAR files. The steps required to "WAR-up" your /onjava web application and deploy it are as follows:

1. Change to the root directory of your web application. In this case the root directory would be TOMCAT_HOME/webapps/onjava/.

2. Archive the web application:

   jar cvf onjava.war .

3. Copy the resulting WAR file, onjava.war, to the TOMCAT_HOME/webapps directory.

   If you're deploying this WAR file to the Tomcat installation that you were developing in, then you will need to back up your development directory and remove it from the TOMCAT_HOME/webapps directory.

4. Add a new Context entry to the /TOMCAT_HOME/conf/server.xml file, referencing the onjava web application.

5. Restart Tomcat.

That's it. Your application should now be deployed and running. If it isn't, check your entry in the TOMCAT_HOME/conf/server.xml file to ensure that you have set the appropriate values.