A web application consists of web components, static resource files such as images, and helper classes and libraries. In the Java 2 platform, web components provide the dynamic extension capabilities for a web server.

Web Components :

• Java Servlets
• JSP
• Web Services endpoint

Web Container :

• Web components are supported by the services of a runtime platform called a web container.
• A web container provides services such as request dispatching, security, concurrency, and life-cycle management. It also gives web components access to APIs such as naming, transactions, and email.

Web application deployment descriptor (DD) : The configuration information is maintained in a text file in XML format called a web application deployment descriptor.

Java Web Application Request Handling

Java Web Application Technologies

Java Web Application Technologies

Servlets are Java programming language classes that dynamically process requests and construct responses.

Servlets are best suited for service-oriented applications (web service endpoints are implemented as servlets) and the control functions of a presentation-oriented application, such as dispatching requests and handling nontextual data.

JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content.

JSP pages are more appropriate for generating text-based markup such as HTML, Scalable Vector Graphics (SVG), Wireless Markup Language (WML), and XML.

Web Application Life Cycle

The process for creating, deploying, and executing a web application can be summarized as follows :

1. Develop the web component code.
2. Develop the web application deployment descriptor.
3. Compile the web application components and helper classes referenced by the components.
4. Optionally package the application into a deployable unit.
5. Deploy the application into a web container.
6. Access a URL that references the web application.

Web Module

Web Resources : In the Java EE architecture, web components and static web content files such as images are called web resources.

Web Module : A web module is the smallest deployable and usable unit of web resources.

In addition to web components and web resources, a web module can contain other files :

• Server-side utility classes (database beans, shopping carts, and so on). Often these classes conform to the JavaBeans component architecture.
• Client-side classes (applets and utility classes).

Structure of Web Module

Top level directory is – Document Root of the application

Document Root contains :

1. JSP pages
2. Client side classes and archives
3. Static web resources, such as images
4. WEB-INF (Sub Directory) contains -
   • web.xml : The web application deployment descriptor
   • Tag library descriptor files
   • classes : A directory that contains server-side classes: servlets, utility classes, and JavaBeans components
   • tags : A directory that contains tag files, which are implementations of tag libraries
   • lib : A directory that contains JAR archives of libraries called by server-side classes

If your web module does not contain any servlets, filter, or listener components then it does not need a web application deployment descriptor.

You can also create application-specific subdirectories in -

• document root or
• WEB-INF/classes/ directory

You can deploy Web Module into any web container that conforms to the Java Servlets Specification.

To deploy a WAR on the Application Server, the file must also contain a Runtime Deployment Descriptor.

Runtime Deployment Descriptor : The runtime deployment descriptor is an XML file that contains information such as the context root of the web application and the mapping of the portable names of an application’s resources to the Application Server’s resources.

The Application Server web application runtime DD is named sun-web.xml and is located in the WEB-INF directory along with the web application DD.

Web Module Structure

Packaging Web Modules
To build the hello1 application with NetBeans IDE, follow these instructions :

1. Select File?Open Project.
2. In the Open Project dialog, navigate to tut-install/javaeetutorial5/examples/web/
3. Select the hello1 folder.
4. Select the Open as Main Project check box.
5. Click Open Project.
6. In the Projects tab, right-click the hello1 project and select Build.

To build the hello1 application using the Ant utility, follow these steps:

1. In a terminal window, go to tut-install/javaeetutorial5/examples/web/hello1/.
2. Type ant. This command will spawn any necessary compilations, copy files to the tut-install/javaeetutorial5/examples/web/hello1/build/ directory, create the WAR file, and copy it to the tut-install/javaeetutorial5/examples/web/hello1/dist/ directory.

Deploying a WAR File
Context Root : A context root identifies a web application in a Java EE server.

• You specify the context root when you deploy a web module.
• A context root must start with a forward slash (/) and end with a string.

Setting the Context Root :
In a packaged web module for deployment on the Application Server, the context root is stored in sun-web.xml.
To edit the context root, do the following :

1. Expand your project tree in the Projects pane of NetBeans IDE.
2. Expand the Web Pages and WEB-INF nodes of your project.
3. Double-click sun-web.xml.
4. In the editor pane, click Edit As XML.
5. Edit the context root, which is enclosed by the context-root element.

You can deploy a WAR file to the Application Server in a 4 ways:

• Copying the WAR into the domain-dir/autodeploy/ directory.
• Using the Admin Console.
• By running asadmin or ant to deploy the WAR.
• Using NetBeans IDE.

Deploying a Packaged Web Module
If you have deployed the hello1 application, before proceeding with this section, undeploy the application by following one of the procedures described in Undeploying Web Modules.

Deploying with the Admin Console

1. Expand the Applications node.
2. Select the Web Applications node.
3. Click the Deploy button.
4. Select the radio button labeled “Package file to be uploaded to the Application Server.”
5. Type the full path to the WAR file (or click on Browse to find it), and then click the OK button.
6. Click Next.
7. Type the application name.
8. Type the context root.
9. Select the Enabled box.
10. Click the Finish button.

Deploying with asadmin
To deploy a WAR with asadmin, open a terminal window or command prompt and execute
=> asadmin deploy full-path-to-war-file

Deploying with Ant
To deploy a WAR with the Ant tool, open a terminal window or command prompt in the directory where you built and packaged the WAR, and execute
=> ant deploy

Deploying with NetBeans IDE
To deploy a WAR with NetBeans IDE, do the following:

1. Select File?Open Project.
2. In the Open Project dialog, navigate to your project and open it.
3. In the Projects tab, right-click the project and select Undeploy and Deploy.

Testing Deployed Web Modules

• By default, the application is deployed to host localhost on port 8080.
• The context root of the web application is hello1 suppose.

To test the application, follow these steps:

1. Open a web browser.
2. Enter the following URL in the web address box : http://localhost:8080/hello1
3. Enter your name, and click Submit.

Listing Deployed Web Modules
To use the Admin Console :

1. Open the URL http://localhost:4848/asadmin in a browser.
2. Expand the nodes Applications?Web Applications.

Use the asadmin command as asadmin list-components

Updating Web Modules

1. Recompile any modified classes.
2. If you have deployed a packaged web module, update any modified components in the WAR.
3. Redeploy the module.
4. Reload the URL in the client.

Dynamic Reloading

• If dynamic reloading is enabled, you do not have to redeploy an application or module when you change its code or deployment descriptors.
• This capability is useful in a development environment, because it allows code changes to be tested quickly.
• Not recommended for a production environment, however, because it may degrade performance.

To enable dynamic reloading, use the Admin Console:

1. Select the Applications Server node.
2. Select the Advanced tab.
3. Check the Reload Enabled box to enable dynamic reloading.
4. Enter a number of seconds in the Reload Poll Interval field to set the interval at which applications and modules are checked for code changes and dynamically reloaded.
5. Click the Save button.

In addition, to load new servlet files or reload deployment descriptor changes, you must do the following:

1. Create an empty file named .reload at the root of the module :
   domain-dir/applications/j2ee-modules/context-root/.reload
2. Explicitly update the .reload file’s time stamp each time you make these changes. On UNIX, execute
   touch .reload

For JSP pages, changes are reloaded automatically at a frequency set in the Reload Poll Interval field. To disable dynamic reloading of JSP pages, set the Reload Poll Interval field value to –1.

Undeploying Web Modules
To use NetBeans IDE:

1. Ensure the Sun Java System Application Server is running.
2. In the Runtime window, expand the Sun Java System Application Server instance and the node containing the application or module.
3. Right-click the application or module and choose Undeploy.

To use the Admin Console:

1. Open the URL http://localhost:4848/asadmin in a browser.
2. Expand the Applications node.
3. Select Web Applications.
4. Click the check box next to the module you wish to undeploy.
5. Click the Undeploy button.

Use the asadmin command as “asadmin undeploy context-root“
To use the Ant tool, execute the following command in the directory where you built and packaged the WAR:
“ant undeploy”

Configuring Web Applications

Mapping URLs to Web Components
When a request is received by the web container it must determine which web component should handle the request. It does so by mapping the URL path contained in the request to a web application and a web component.

A URL path contains the context root and an alias
“http://host:port/context-root/alias”

The Component Alias

1. The alias identifies the web component that should handle a request.
2. The alias path must start with a forward slash (/) and end with a string or a wildcard expression with an extension (for example, *.jsp).
3. Since web containers automatically map an alias that ends with *.jsp, you do not have to specify an alias for a JSP page unless you wish to refer to the page by a name other than its file name.

Declaring Welcome Files

1. The welcome files mechanism allows you to specify a list of files that the web container will use for appending to a request for a URL (called a valid partial request) that is not mapped to a web component.
2. If a web container receives a valid partial request, the web container examines the welcome file list and appends to the partial request each welcome file in the order specified and checks whether a static resource or servlet in the WAR is mapped to that request URL. The web container then sends the request to the first resource in the WAR that matches.
3. If no welcome file is specified, the Application Server will use a file named index.XXX, where XXX can be html or jsp, as the default welcome file. If there is no welcome file and no file named index.XXX, the Application Server returns a directory listing.

To specify a welcome file in the web application deployment descriptor, do the following:

• Open web.xml
• Specify the JSP pages using welcome-file elements and include these elements inside a welcome-file-list element. The welcome-file element defines the JSP page to be used as the welcome page.

Setting Initialization Parameters
You can pass initialization parameters to the context or to a web component.

To add a context parameter, do the following:

1. Open web.xml.
2. Using the following elements to add a context parameter
   • A param-name element that specifies the context object
   • A param-value element that specifies the parameter to pass to the context object
   • A context-param element that encloses the previous two elements

To add a web component initialization parameter, do the following:

1. Open web.xml.
2. Using the following elements to add a context parameter
   • A param-name element that specifies the name of the initialization parameter
   • A param-value element that specifies the value of the initialization parameter
   • An init-param element that encloses the previous two elements

Mapping Errors to Error Screens
When an error occurs during execution of a web application, you can have the application display a specific error screen according to the type of error.

To set up error mappings, do the following:

1. Open web.xml
2. Using the following elements
   • An exception-type element specifying either the exception or the HTTP status code that will cause the error page to be opened.
   • A location element that specifies the name of a web resource to be invoked when the status code or exception is returned. The name should have a leading forward slash (/).
   • An error-page element that encloses the previous two elements.
     You can have multiple error-page elements in your deployment descriptor.

Declaring a Reference to a Resource

1. The @Resource annotation is used to declare a reference to a resource such as a data source, an enterprise bean, or an environment entry.
2. This annotation is equivalent to declaring a resource-ref element in the deployment descriptor.
3. The @Resource annotation is specified on a class, method or field.
4. The container is responsible for injecting references to resources declared by the @Resource annotation and mapping it to the proper JNDI resources.

Example

If you have multiple resources that you need to inject into one component, you need to use the @Resources annotation to contain them, as shown by the following example

Declaring a Reference to a Web Service

1. The @WebServiceRef annotation provides a reference to a web service.
2. WebServiceRef uses the wsdlLocation element to specify the URI of the deployed service’s WSDL file.

Example

REFERENCES

1. http://java.sun.com/javaee/5/docs/tutorial/doc/geysj.html
2. http://java.sun.com/javaee/5/docs/tutorial/doc/bnadx.html
3. http://java.sun.com/javaee/5/docs/tutorial/doc/