Question

Fill in the blanks in each of the following statements: a) A three-ticr, distributed Web application consists of _______,________and _________ tier. b) The _______ is the default document sent as the response to a client when the client initially interacts with a J2EE application. c) The ______ enables Enterprise Java application components to access information and resources (such as databases) that are external to an application. d) An ________ object provides access to the application’s naming environment. e) A RequestDispatcher object can _____ requests to other resources or _______ other resources as part of the current servlet’s response. f) Sun’s _________ provides XML and XSL capabilities in a Java program. g) Method _____ of interface _______ discards the session object for the current client. h) The _______for an application is the part of the URL that enables the server to deter- mine which application to execute when the server receives a request from a client. i) An Enterprise Java application container must provide a ______ that implements JNDI and enables the components executing in that container to perform name lookups to locate resources. j) The J2EE reference implementation comes with a graphical application, called the ________ that helps you deploy Enterprise Java applications.

Short answer

a) presentation, application logic, data; b) index.html; c) Resource Manager; d) ENC reference; e) forward, include; f) JAXP; g) invalidate, HttpSession; h) context path; i) JNDI; j) Application Server Control.

Step-by-step solution

Recognizing Tiers in Web Application

Web applications are usually divided into three tiers: the presentation, application logic, and data tier. The presentation tier is where the user interface resides, the application logic tier processes data between the user interface and database, and the data tier is where the data is stored and managed.

Default Document in J2EE Application

In J2EE applications, the default document is typically the `index.html` or `index.jsp`. This file is automatically served to the client upon initial interaction if no specific page is requested.

Enterprise Java Access to External Resources

In Enterprise Java, the Resource Manager enables components to access external resources such as databases and enterprise information systems. This is often done via a standardized set of APIs or interfaces.

Accessing Application's Naming Environment

An environment naming context (ENC) reference is provided by Java Naming and Directory Interface (JNDI) to access the application's naming environment, which allows Java objects to connect to object stores or to find other objects in a network.

Using RequestDispatcher

A RequestDispatcher object in JavaServer Pages can either forward the request to another resource or include the content of another resource in the response. This is facilitated by the methods `forward()` or `include()`.

XML and XSL in Java

Sun's Java API for XML Processing (JAXP) provides XML parsing and XSL transformations capabilities in Java applications. This API enables developers to manipulate XML data easily.

Discarding Session Objects

The `invalidate()` method of the `HttpSession` interface is used to discard an existing session object, effectively logging the user out or ending the session.

Determining Application in URL

The context path is the part of the URL used by the server to determine which application to execute. This is often the part that follows the domain and precedes any specific resource identifiers.

JNDI Implementation in Java Containers

Containers in Enterprise Java must provide an implementation of Java Naming and Directory Interface (JNDI) to allow components to perform name lookups for resources.

Deploying Enterprise Java Applications

The J2EE reference implementation includes a tool called the 'Application Server Control', which is a graphical application that aids in deploying Enterprise Java applications.

Key concepts

Web Application Tiers

A web application is typically organized into three primary tiers, each serving a unique role. These tiers are:

• Presentation Tier: This is the topmost level where the user interacts with the application. It is essentially the user interface layer, composed of web browsers, client-side web apps, or front-end interfaces that present the application's data to users.


• Application Logic Tier: Also called the business logic tier, this is where the core functionalities of the application are executed. This layer processes the user's requests, performs calculations, accesses databases, and ensures that web services and business logic are executed correctly.


• Data Tier: At the back end of the application setup, this tier manages the data storage and retrievals. It's where databases store and manage data, ensuring the proper data is available to the application logic tier when needed.

These layers work together to ensure that web applications are scalable, efficient, and maintainable, allowing distinct processes to operate independently yet collaboratively.

RequestDispatcher

In the realm of Java EE web applications, the RequestDispatcher plays a crucial role in managing requests between different components of the application. It is part of the servlet API and is used for inter-servlet communication.

A RequestDispatcher object can perform two main tasks:

• Forwarding Requests: The `forward()` method allows a servlet to forward the request to another resource, such as another servlet, JSP file, or an HTML file. It is used when you want to pass control to another component within the same application.


• Including Content: The `include()` method enables a servlet to include content from another resource within the response generated by the servlet. It's useful when you want to incorporate another resource's output, like headers or footers, into the response.

Utilizing RequestDispatcher effectively enables seamless integration of different components, ensuring better application flow and modularization.

Java Naming and Directory Interface (JNDI)

The Java Naming and Directory Interface (JNDI) is a powerful Java API designed to provide naming and directory functionality to Java applications. Think of JNDI as a directory service that allows Java applications to discover and look up data and resources by names rather than physical or network paths.

Here’s how JNDI is typically used in Java EE:

• Naming: It helps in accessing the names of objects such as EJBs (Enterprise JavaBeans) or JMS (Java Message Service) components defined in the environment, thus simplifying resource access.


• Directory: JNDI supports various directory services to which Java applications can be connected. These include LDAP, DNS, and more, allowing for a universal approach to interacting with various directory and naming services.


• Resource Lookup: Within Java EE environments, JNDI is crucial for performing lookups for resources like databases, queues, etc.

By providing a consistent API for accessing a wide range of naming and directory services, JNDI offers developers a straightforward way to work with application resources.

HttpSession Interface

State management in web applications is essential, given that HTTP is a stateless protocol. This is where the HttpSession interface in Java EE comes into play. It maintains session state between the client and the server, ensuring that a user's state persists across multiple requests.

Key functionalities of the HttpSession interface include:

• Session Creation: As soon as a user interacts with a web server application, a session is created to keep track of the user's activities.


• Session Tracking: HttpSession helps associate each user with an individual session, uniquely tracked using a session ID. This ID is sent between the client and server in requests and responses.


• Session Invalidating: Using the `invalidate()` method, applications can end a user session. This method ensures that the user's session data is discarded, effectively logging the user out or cleaning up resources.

Overall, HttpSession is crucial for maintaining users' state within web applications, thereby enhancing user experience by tracking interactions seamlessly.