Getting Started with Web Applications

by Dr. Wenjie He

Introduction to Web Applications

What is a web applcation?

A web application is an application that is accessed via web browser over a network. Server-side technologies, such as Java EE, Microsoft .NET, and PHP, are used to provide dynamic functionalities for a web application. A database is usually necessary to provide data storage for a mission-critical web application.

In this class, we only focus on the Java-based web technologies. From now on, when we mention web applications, we mean those web applications that use the Java-based web technologies.

Three-tier architecture

• Presentation tier (or client tier)

This tier presents information in a web browser and makes requests to the business logic tier.

• Business logic tier (or web tier)

This tier processes the requests from the presentation tier and sends the database queries to the database access tier. It is responsible for generating response for clients.

• Database access tier (or data tier)

This tier responds to the database query requests from the business logic tier.

Technologies used in three-tier architecture

Tier	Technologies
Presentation	HTML/XHTML, CSS, etc.
Business logic	Servlets, JavaServer Pages, tag libraries, etc.
Database access	MySQL, Oracle, etc.

Purpose of web applications

A web application bundles all the web content into a single collection that can be used on any server compatible with servlet specification. The main purpose of web applications are three folds:

• Organization
  Web applications have a standard location for each type of resource based on the Java EE specification. The standard file organization streamlines the development.
• Portability
  The standard file organization also helps the portability. The web applications developed following this specification should be able to deploy and run in any compliant server. This makes Tomcat the post popular server for web application development. A vendor-supported server is usually used for production.
• Separation
  Different web applications deployed on the same server do not interfere with each other. Two web applications deployed on the same server act as if they were deployed on sparate servers. They refer to each other by their URLs.

Web Container

A web container is a runtime platform that provides the services to web components. A Web container is essentially the component of a Web server that interacts with the servlets. The Web container is responsible for managing the lifecycle of servlets. In other words, a web container is essentially a servlet container.

Web Components

Web components provide the dynamic extension capabilities for a web server. When a web-based client such as a browser communicates with a Java EE application, it does so through web components. There are three types of web components:

• Java servlets
• JSP pages
• Web service endpoints

Note: The JavaBeans components are not web components.

Request-response model

The communication between client and web tiers and the communication between web and data tiers adopt the fundamental request-response model.

• The client (web browser) sends an HTTP request to the web server (Java-based).
• The HTTP request is a text stream (with which binary files can be attached) that follows the HTTP protocol, and the programmers are not supposed to handle the HTTP request directly.
• A web server that implements Java Servlet and JavaServer Pages technology converts the HTTP request into an HTTPServletRequest object.
• This HTTPServletRequest object carries all the data that the users enter into the forms of the web pages, and it can be conveniently handled by Java classes.
• This HTTPServletRequest object is delivered to a web component, such as a servlet or a JSP, which can interact with JavaBeans components or a database to generate dynamic content.
• The web component can then generate an HTTPServletResponse object or it can pass the request to another web component. Eventually a web component generates a HTTPServletResponse object.
• The web server converts this object HTTPServletResponse to an HTTP response and returns it to the client.

First Look of JavaServer Pages

• JavaServer Pages (JSP) is an extension of servlet technology.
• JSP simplify the delivery of dynamic web content.
• JSP source files use .jsp extension.
• JSP scriplets (or scripting elements) enable programmers to insert Java code that provides the dynamic content in a JSP.
• JSP are derived from HTML or XHTML by embedding JSP scriplets.

Structures of Web Applications

Organization

• Root directory
  It contains all the resources for the web application. All the files and the subdirectories except WEB-INF are directly accessible to clients through URLs.
• WEB-INF
  It is directly under the root directory, and is invisible to a visiting web browser. It contains the deployment descriptor file web.xml and subdirectories classes and lib.
• WEB-INF\web.xml
  The deployment descriptor file, web.xml, configures the resources such as servlets and welcome files of the web application. It must conform to the schema described in the Java Servlet Specification.
• WEB-INF\classes
  Individual Java classes, such as servlets, beans, and helper classes, are in this directory.
• WEB-INF\lib
  JAR files always go in this directory.

Analysis of Duke Example

File structure of Duke

Duke
Duke\index.jsp
Duke\response.jsp
Duke\duke.waving.gif
Duke\WEB-INF
Duke\WEB-INF\web.xml

Since there are no servlets and JavaBeans in this example, the folder Duke\WEB-INF\classes is not needed. We do not use any libraries in this example, so there is no Duke\WEB-INF\lib folder.

Static resource

An image file: Duke\duke.waving.gif

Web components

Web components mean dynamic resouces of the web application. There are two web components in this example: Duke\index.jsp and Duke\response.jsp.

Code Listing: Duke\index.jsp

 
	1:	<%@page contentType="text/html"%>
	2:	<%@page pageEncoding="UTF-8"%>
	3:
	4:	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
	5:	   "http://www.w3.org/TR/html4/loose.dtd">
	6:	
	7:	<html>
	8:	<head><title>Hello</title></head>
	9:	<body bgcolor="white">
	10:	<img src="duke.waving.gif"> 
	11:	<h2>Hello, my name is Duke. What's yours?</h2>
	12:	<form method="get">
	13:	<input type="text" name="username" size="25">
	14:	<p></p>
	15:	<input type="submit" value="Submit">
	16:	<input type="reset" value="Reset">
	17:	</form>
	18:
	19:	<%
	20:	   String name = request.getParameter("username");
	21:	   if (name != null) {
	22:	%>
	23:	       <%@include file="response.jsp" %>
	24:	<%
	25:	   }
	26:	%> 
	27:
	28:	</body>
	29:	</html>
	

Explanation:

• A JSP directive gives special information about the page to the JSP Engine. There are three main types of directives:
  • page - processing information for this page
  • include - files to be included
  • taglib - tag library to be used in this page
  Directives do not produce any visible output when the page is requested but change the way the JSP Engine processes the page. (See line 1, 2, 23.)
• JSP scriplets are blocks of Java code delimiled by <% and %>. They contain Java statements that the container needs to compile before they can be used. (See 19-22 and 24-26.)
• Line 23 uses the include directive to specify another page to be included at the current location with the file attribute.
• Implicit objects provide programmers with access to many servlet capabilities in the context of a JavaServer Page. Line 20 uses the request JSP implicit object that is an HTTPServletRequest object created by the container. Then the value of the parameter username can be accessed through its getParameter method.

Code Listing: Duke\response.jsp

	1:	<h2><font color="black">Hello, <%= request.getParameter("username") %>!</font></h2>
      

Explanation:

• Line 1 uses the JSP expression. A JSP expression, delimited by <%= and %>, contains a Java expression that is evaluated when a client requests the JSP containing the expression.
• The container converts the result of a JSP expression to a String object, then outputs the String as part of the response to the client.

Deployment descriptor web.xml

Code Listing: Duke\WEB-INF\web.xml

           
	1:	<?xml version="1.0" encoding="UTF-8"?>
	2:
	3:	<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
	4:		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	5:		 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	6:		 version="2.4">
	7:	    <session-config>
	8:	        <session-timeout>
	9:	            30
	10:	        </session-timeout>
	11:	    </session-config>
	12:	    <welcome-file-list>
	13:		<welcome-file>
	14:	            index.jsp
	15:	        </welcome-file>
	16:	    </welcome-file-list>
	17:	</web-app>
        

• The deployment descriptor is not part of the Java compilation process. The separation of the configuration mechanism and Java code allows for the division between the development and deployment. The application behavior can be adjusted by editing the web.xml without changing the Java code.
• It is placed in the WEB-INF directory within each web application.
• The deployment descriptor must begin with an XML header. This header declares the version of XML. (See line 1.)
• XML elements are case sensitive.
• The top-level (root) element for the deployment descriptor is web-app. (See line 3 and line 17.)
• An XML schema instance must be declared as part of the web-app element. This declaration tells the server the version of the specification that applies and specifies the XML schema location that governs the syntax of the rest of the file. (See line 3-6.)
• In line 3-6, only URL http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd must actually exists, pointing to the location of the XML schema file. The rest of the URL looking strings are namespaces.
• Namespaces are just unique identifiers for a particular schema syntax and could be any unique string. The server never connects to the namespace (fake) URLs.
• The servlet version 2.3 is still used a lot. The servlet version 2.4 is prefered to version 2.3, because a very useful feature of version 2.4 -- JSP Expression Language is not supported in version 2.3.
• The order of the subelements of web-app does not matter if you are using version 2.4. This is one of the major differences between web.xml of version 2.4 and earlier versions.
• In line 7-11, we set the default timeout for a session in the web application. The units are minutes. In this example, if a session has not been accessed for 30 minutes, the server can throw it away to save memory.
• The welcome-file-list element tells the server what file to use when the server receives URLs that refer to the context-root name (sometimes the same as the directory name) but not a file name.
• You can specify more than one welcome file as in the following example,

 
		<welcome-file-list>
			<welcome-file>index.jsp</welcome-file>
			<welcome-file>index.html</welcome-file>
		</welcome-file-list>
	 

The server would try index.jsp first and index.html second. If neither is found, the result is server specific.

Question: What would happen in Tomcat if there is no welcome file given in the web.xml?

Exercise

Problem:

Create a web application that uses the file clock.jsp as a web component. Then you run it in Tomcat and see the result.

Requirements:

• You need to create your own configuration file web.xml.
• You need to configure the welcome file of your wen application in the web.xml.
• You need to create a folder for your web application with a file structure that satisfies the servlet specification.

==========The End==========