EE
**
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.
In a packaged web module for deployment on the Sun Application Server, the
context root is stored in ``sun-web.xml``.
Deployment descriptors
======================
There are two types of deployment descriptors: Java EE and runtime. A Java EE
deployment descriptor is defined by a Java EE specification and can be used to
configure deployment settings on any Java EE-compliant implementation. A
runtime deployment descriptor is used to configure Java EE
*implementation-specific* parameters.
EAR
===
A Java EE application is delivered in an Enterprise Archive (EAR) file, a
standard Java Archive (JAR) file with an ``.ear`` extension.
An EAR file contains Java EE modules and deployment descriptors. A deployment
descriptor is an XML document with an .xml extension that describes the
deployment settings of an application, a module, or a component.
EIS
===
The enterprise information system tier handles EIS software and includes
enterprise infrastructure systems such as enterprise resource planning (ERP),
mainframe transaction processing, database systems, and other legacy
information systems. For example, Java EE application components might need
access to enterprise information systems for database connectivity.
Enterprise Bean
===============
From *EJB 3 in Action*, Manning Publications Co. An annotation transforms a
simple POJO into an EJB:
POJO + Annotation = EJB
::
../../images/howto/j2ee/pojo+annotation-ejb.gif
Business code, which is logic that solves or meets the needs of a particular
business domain such as banking, retail, or finance, is handled by enterprise
beans running in the business tier. Figure 14?? shows how an enterprise bean
receives data from client programs, processes it (if necessary), and sends it
to the enterprise information system tier for storage. An enterprise bean also
retrieves data from storage, processes it (if necessary), and sends it back to
the client program.
Figure 1-4: Business and EIS Tiers
::
../../images/howto/j2ee/ee-business-and-eis-tiers.gif
An Enterprise JavaBeans (EJB) component, or enterprise bean, is a body of code
having fields and methods to implement modules of business logic. You can think
of an enterprise bean as a building block that can be used alone or with other
enterprise beans to execute business logic on the Java EE server.
There are two kinds of enterprise beans: session beans and message-driven beans:
- A session bean represents a transient conversation with a client. When the
client finishes executing, the session bean and its data are gone.
- A message driven bean combines features of a session bean and a message
listener, allowing a business component to receive messages asynchronously.
Entity beans
============
In Java EE 5, entity beans have been replaced by Java persistence API entities.
An entity represents persistent data stored in one row of a database table.
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. In
particular, you can specify a mapping between the status code returned in an
HTTP response or a Java programming language exception returned by any web
component and any type of error screen e.g.
::
404
/notfound.jsp
java.lang.Throwable
/error.jsp
Filter
======
A filter is an object that can transform the header and content (or both) of a
request or response. Filters differ from web components in that filters
usually do not themselves create a response. Instead, a filter provides
functionality that can be *attached* to any kind of web resource.
html
====
Static HTML pages and applets are bundled with web components during
application assembly but are not considered web components by the Java EE
specification.
JavaBeans
=========
JavaBeans components manage the data flow between an application client or
applet and components running on the Java EE server, or between server
components and a database. JavaBeans components are not considered Java EE
components by the Java EE specification. JavaBeans components have properties
and have get and set methods for accessing the properties.
The web tier, like the client tier, might include a Java-Beans component to
manage the user input and send that input to enterprise beans running in the
business tier for processing.
Request
=======
A request contains data passed between a client and the servlet. All requests
implement the ``ServletRequest`` interface.
Response
========
All responses implement the ``ServletResponse`` interface. This interface
defines methods that allow you to:
- Retrieve an output stream to use to send data to the client. To send
character data, use the ``PrintWriter`` returned by the response's
``getWriter`` method. To send binary data in a ``MIME`` body response, use
the ``ServletOutputStream`` returned by ``getOutputStream``. To mix binary
and text data, for example to create a multipart response - use a
``ServletOutputStream`` and manage the character sections manually.
- Indicate the content type (for example, ``text/html``) being returned by the
response with the ``setContentType(String)`` method. This method must be
called before the response is committed. A registry of content type names is
kept by the Internet Assigned Numbers Authority (IANA) at:
http://www.iana.org/assignments/media-types/
- Indicate whether to buffer output with the ``setBufferSize(int)`` method.
By default, any content written to the output stream is immediately sent to
the client. Buffering allows content to be written before anything is
actually sent back to the client, thus providing the servlet with more time
to set appropriate status codes and headers or forward to another web
resource.
The method must be called before any content is written or before the
response is committed.
HTTP response objects, ``HttpServletResponse``, have fields representing HTTP
headers such as the following:
- Status codes, which are used to indicate the reason a request is not
satisfied or that a request has been redirected.
- Cookies, which are used to store application-specific information at the
client. Sometimes cookies are used to maintain an identifier for tracking a
user's session.
Servlets
========
Servlets are Java programming language classes that dynamically process
requests and construct responses.
The ``HttpServlet`` class provides methods, such as doGet and doPost (other
options might be *Delete*, *Options*, *Put*, or *Trace*), for handling
HTTP-specific services.
URL
===
A URL path contains the context root and an alias:
http://host:port/context_root/alias
The alias identifies the web component that should handle a request. The alias
path must start with a forward slash (``/``) and end with a string or a
wildcard expression with an extension (for example, ``*.jsp``).
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.
Web Context
===========
The web components in a web module share an object that represents their
application context. You can pass initialization parameters to the context or
to a web component.
Welcome File List
=================
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.