Home TOC Index

Web Application Archives

If you want to distribute a Web application, you package it in a Web application archive (WAR), which is a JAR similar to the package used for Java class libraries. In addition to Web components, a Web application archive can contain other files including the following:

• Server-side utility classes (database beans, shopping carts, and so on). Often these classes conform to the JavaBeans component architecture.
• Static Web presentation content (HTML, image, and sound files, and so on)
• Client-side classes (applets and utility classes)

Web components and static Web content files are called Web resources.

A Web application can run from a WAR file or from an unpacked directory laid out in the same format as a WAR.

WAR Directory Structure

The top-level directory of a WAR is the document root of the application. The document root is where JSP pages, client-side classes and archives, and static Web resources are stored.

The document root contains a subdirectory called WEB-INF, which contains the following files and directories:

• web.xml - The Web application deployment descriptor
• Tag library descriptor files (see Tag Library Descriptors)
• classes - A directory that contains server-side classes: servlets, utility classes, and JavaBeans components
• lib - A directory that contains JAR archives of libraries (tag libraries and any utility libraries called by server-side classes)

You can also create application-specific subdirectories (that is, package directories) in either the document root or the WEB-INF/classes directory.

Tutorial Example Directory Structure

To facilitate iterative development and keep Web application source separate from compiled files, the source code for the tutorial examples is stored in the following structure under each application directory mywebapp:

• build.xml - Ant build file
• context.xml - Optional application configuration file
• src - Java source of servlets and JavaBeans components
• web - JSP pages and HTML pages, images

The Ant build files (build.xml) distributed with the examples contain targets to create an unpacked WAR structure in the build subdirectory of mywebapp, copy and compile files into that directory, and invoke the manager (see Tomat Web Application Manager) commands via special Ant tasks to install, reload, remove, deploy, and undeploy applications. The tutorial example Ant targets are:

• prepare - Creates build directory and WAR subdirectories.
• build - Compiles and copies the mywebapp Web application files into the build directory.
• install - Notifies Tomcat to install an application (see Installing Web Applications) using the Ant install task.
• reload - Notifies Tomcat to reload the application (see Updating Web Applications) using the Ant reload task.
• deploy - Notifies Tomcat to deploy the application (see Deploying Web Applications) using the Ant deploy task.
• undeploy - Notifies Tomcat to undeploy the application (see Undeploying Web Applications) using the Ant undeploy task.
• remove - Notifies Tomcat to remove the application (see Removing Web Applications) using the Ant remove task.

Creating a WAR

You can manually create a WAR in two ways:

• With the JAR tool distributed with the J2SE SDK. You simply execute the following command in the build directory of a tutorial example:

    jar cvf mywebapp.war .
   
  

• With the Ant war task

Both of these methods require you to have created a Web application deployment descriptor.

You can also package an application into a WAR using deploytool. When you use deploytool, it creates a Web application deployment descriptor based on information entered into deploytool wizards and inspectors. To build and package the Hello1 application into a WAR named hello1.war:

1. In a terminal window, go to <JWSDP_HOME>/docs/tutorial/examples/web/hello1.
2. Run ant build. The build target will spawn any necessary compilations and copy files to the <JWSDP_HOME>/docs/tutorial/examples/web/hello1/build directory.
3. Start deploytool.
4. Create a Web application called hello1.
   1. Select FileNew Web Application.
   2. Select the Create New Stand-Alone WAR Module.
   3. Click Browse and in the file chooser, navigate to <JWSDP_HOME>/docs/tutorial/examples/web/hello1.
   4. In the File Name field, enter hello1.
   5. Click Choose Module File.
   6. In the WAR Display Name field enter hello1.
5. Add the greeting Web component and all of the Hello1 application content.
   1. Click Edit to add the content files.
   2. In the Edit Contents dialog, select <JWSDP_HOME>/docs/tutorial/examples/web/hello1/build/duke.waving.gif and click Add. Navigate to WEB-INF/classes and select GreetingServlet.class, and ResponseServlet.class and click Add. Click OK.
   3. Click Next.
   4. Select the Servlet radio button.
   5. Click Next.
   6. Select GreetingServlet from the Servlet Class combo box.
   7. Click Finish.
6. Add the response Web component.
   1. Select FileEdit Web Application.
   2. Click the Add to Existing WAR Module radio button and select hello1 from the combo box. Since the WAR contains all of the servlet classes, you do not have to add any more content.
   3. Click Next.
   4. Select the Servlet radio button.
   5. Click Next.
   6. Select ResponseServlet from the Servlet Class combo box.
   7. Click Finish.

Home TOC Index

This tutorial contains information on the 1.0 version of the Java Web Services Developer Pack.

All of the material in The Java Web Services Tutorial is copyright-protected and may not be published in other works without express written permission from Sun Microsystems.