type=page
status=published
title=Web Applications
next=webapp002.html
prev=webapp.html
~~~~~~
Web Applications
================

[[GEYSJ]]

[[web-applications]]
Web Applications
----------------

A web application is a dynamic extension of a web or application server.
Web applications are of the following types:

* Presentation-oriented: A presentation-oriented web application
generates interactive web pages containing various types of markup
language (HTML, XHTML, XML, and so on) and dynamic content in response
to requests. Development of presentation-oriented web applications is
covered in link:jsf-intro.html#BNAPH[Chapter 7, "JavaServer Faces
Technology,"] through link:servlets.html#BNAFD[Chapter 18, "Java Servlet
Technology."]
* Service-oriented: A service-oriented web application implements the
endpoint of a web service. Presentation-oriented applications are often
clients of service-oriented web applications. Development of
service-oriented web applications is covered in
link:jaxws.html#BNAYL[Chapter 31, "Building Web Services with JAX-WS,"]
and link:jaxrs.html#GIEPU[Chapter 32, "Building RESTful Web Services with
JAX-RS,"] in link:partwebsvcs.html#BNAYK[Part III, "Web Services."]

In the Java EE platform, web components provide the dynamic extension
capabilities for a web server. Web components can be Java servlets, web
pages implemented with JavaServer Faces technology, web service
endpoints, or JSP pages. link:#BNADS[Figure 6-1] illustrates the
interaction between a web client and a web application that uses a
servlet. The client sends an HTTP request to the web server. A web
server that implements Java Servlet and JavaServer Pages technology
converts the request into an `HTTPServletRequest` object. This object is
delivered to a web component, which can interact with JavaBeans
components or a database to generate dynamic content. The web component
can then generate an `HTTPServletResponse` or can pass the request to
another web component. A web component eventually generates a
`HTTPServletResponse` object. The web server converts this object to an
HTTP response and returns it to the client.

[[BNADS]]

.*Figure 6-1 Java Web Application Request Handling*
image:img/javaeett_dt_013.png[
"Diagram of web application request handling. Clients and servlets
communicate using HttpServletRequest and HttpServletResponse."]

Servlets are Java programming language classes that dynamically process
requests and construct responses. Java technologies, such as JavaServer
Faces and Facelets, are used for building interactive web applications.
(Frameworks can also be used for this purpose.) Although servlets and
JavaServer Faces and Facelets pages can be used to accomplish similar
things, each has its own strengths. Servlets are best suited for
service-oriented applications (web service endpoints can be implemented
as servlets) and the control functions of a presentation-oriented
application, such as dispatching requests and handling nontextual data.
JavaServer Faces and Facelets pages are more appropriate for generating
text-based markup, such as XHTML, and are generally used for
presentation-oriented applications.

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

Certain aspects of web application behavior can be configured when the
application is installed, or deployed, to the web container. The
configuration information can be specified using Java EE annotations or
can be maintained in a text file in XML format called a web application
deployment descriptor (DD). A web application DD must conform to the
schema described in the Java Servlet specification.

This chapter gives a brief overview of the activities involved in
developing web applications. First, it summarizes the web application
lifecycle and explains how to package and deploy very simple web
applications on GlassFish Server. The chapter then moves on to
configuring web applications and discusses how to specify the most
commonly used configuration parameters.
