• Client-tier components run on the client machine.
• Web-tier components run on the J2EE server.
• Business-tier components run on the J2EE server.
• Enterprise information system (EIS)-tier software runs on the EIS server.

J2EE applications are composed of J2EE components. A J2EE component
is a discrete unit of functional software that may be assembled along with
other components into a J2EE application.The J2EE specification defines the
following J2EE components:

• Application clients and applets     // both components run on the client
• Java Servlet and Java Server Pages // Web components that run on the server.
• Enterprise JavaBeans      // business components that run on the server

• assembled into J2EE applications
• verified to be well formed and in compliance with the J2EE specification
• deployed to production, where they are run and managed by the J2EE server.

J2EE Clients

A J2EE client is described as being either a Web client or an application client.
There are two forms that the web client takes. The first is a servlet or JSP based
client and the second is a standalone Java application.

Web Clients

Applets

A variation of the web client includes an embedded applet in the downloaded Web
pages which can process locally inside the context of a browsers JRE or Java
Runtime Environment. Applets make demands on client systems, likely needing
a Java Plug-in and possibly a security policy file in order for successful operation.
execute in the Web browser.
 

J2EE Client Preferences

Web components such Servlets and Java Server Pages are preferred over Applets
because no plug-ins or security policy files are needed on the Client.  Generally,
modular application designs which separate applications programming from Web
page design are favored. By keeping dynamic code exposure in presentation pages
to a minimum, workers involved in Web page design will not need to understand
Java to perform their roles.
 

Application Clients    // 'J2EE application client' (read a standalone swing application)

Optional Use of JavaBeans

Optionally the server and client tiers might include JavaBean components. JavaBeans
are often used to facilitate data flow between a client and server or between server and
a database. // not to be confused with EJBs

JavaBeans components are not considered 'official' J2EE components by the J2EE
specification. When JavaBeans are used in the context of J2EE components, they are
usually kept simple in design, supplying get and set methods for instance variable, in
keeping with the naming conventions of JavaBeans. The following figure summarizes
the various components that can be used to make up a J2EE application.

Web Components  // Servlets & JSPs

J2EE Web components can be either Servlets or JSP pages. Servlets are Java programming
server-side classes that dynamically process requests and create responses. JSP pages are
text-based documents that that are translated into servlets. JSPs provide more natural method
of creating static content.

Business Components  

"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.
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 may also retrieves
data from storage, processes it and sends it back to the client program."
 

Business and EIS Tiers // EnterpriseJava Beans,EJBs , session, entity or message-driven  

There are three kinds of enterprise beans: session beans, entity 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. In contrast, an entity bean represents
persistent data stored in one row of a database table. If the client terminates or if the server
shuts down, the underlying services ensure that the entity bean data is saved. A message-
driven bean combines features of a session bean and a Java Message Service ("JMS")
message listener, allowing a business component to receive JMS messages asynchronously.
 

Enterprise Information System Tier  // access via JDBC and JNDI 

The enterprise information system tier handles enterprise information system software and
includes enterprise infrastructure systems such as enterprise resource planning (ERP),
mainframe transaction processing, database systems, and other legacy information systems.

Multitiered applications have traditionally been difficult to program due to complex
issues such as transaction and state management, security, multithreading and
resource pooling. The J2EE architecture makes applications easier to create by
allowing business logic to be placed in reusable components while complex low-
level features are handled by the 'Container' that is hosting the application at each
tier of the J2EE network. This provides an efficient division of labour where
developers are allowed to focus on business processes while the 'Container'
application providers can focus on engineering solutions for features that are
highly techincal in nature and which have little to do with the day-to-day operations
of a business.

Container Services

Containers are the interface between a component and the low-level platform-specific
functionality that supports the component. Before a J2EE component can be executed,
it must be assembled into a J2EE application and deployed into its container. The
assembly process involves: 

• specifying container settings for components and the J2EE application itself.
• specifiying Container settings for the support the J2EE server will provide *

Container Types

The deployment process installs J2EE application components in the J2EE containers.
This view has been expanded to include a client container. The types are listed below.

J2EE Server - The J2EE server is the runtime portion of a J2EE product. A J2EE
server provides EJB and Web containers.

J2EE Server
 

EJB Container

Web Container

Enterprise JavaBeans (EJB) container - The EJB container manages the execution
of enterprise beans for J2EE applications. Enterprise beans and their container run on
the J2EE server.

 EJB Container
 

EJB Container

Web Container - Manages the execution of JSP page and servlet components for
J2EE applications. Web components and their container run on the J2EE server.

Web Container
 

Web Container

Application Client Container - The application client container manages the execution
of application client components. Application clients and their container run on the client.

Application Client  Container
 

Web Container

Applet Container - The applet container manages the execution of applets. It consists
of a Web browser and Java Plug-in running on the client together.

"J2EE components are packaged separately and bundled into a J2EE application
for deployment. Each component, its related files such as GIF and HTML files or
server-side utility classes, and a deployment descriptor are assembled into a module
and added to the J2EE application. A J2EE application is composed of one or more
enterprise bean, Web, or application client component modules. The final enterprise
solution can use one J2EE application or be made up of two or more J2EE applications,
depending on design requirements."

The Deployment Descriptor // a configuration file for the enterprise bean written in XML

A deployment descriptor is an XML document with an .xml extension that describes a
component's deployment settings. An enterprise bean module deployment descriptor,
for example, declares transaction attributes and security authorizations for an enterprise
bean. Because deployment descriptor information is declarative, it can be changed
without modifying the bean source code. At run time, the J2EE server reads the
deployment descriptor and acts upon the component accordingly.

Enterprise Archive File ( EAR )    // a jar with an ear extension

A J2EE application with all of its modules is delivered in an Enterprise Archive or EAR
file. An EAR file is a standard Java Archive (JAR) file with an .ear extension. In the GUI
version of the J2EE SDK application deployment tool, you create an EAR file first and
add JAR and Web Archive (WAR) files to the EAR. If you use the command line packager
tools, however, you create the JAR and WAR files first and then create the EAR. The
J2EE SDK tools are described in the section Tools.

"Using modules and EAR files makes it possible to assemble a number of different J2EE
applications using some of the same components. No extra coding is needed; it is just a
matter of assembling various J2EE modules into J2EE EAR files."

Summary Overview of The Three Archive Types and What They Contain
 

JAR -Client Zone	WAR -Web Zone	EAR Enterprise Zone
The Java Archive File stores the  deployment descriptor, client app class files and related files.	The Web Archive File stores the deployment descriptor, web component class files and related resources	The Enterprise Archive File stores the deployment descriptor, enterprise bean files and related files.

Every servlet has to implement the Servlet interface. Most servlets will implement
this interface by extending the Servlet implementation classes, GenericServlet or
HttpServlet. GenericServlet is extended when developing a protocol-independent
servlet, while HttpServlet is normally extended for an HTTP dependent servlet.
 

Servlets are a Hosted Form of Application Like Applets

The service( )  method

The heart of the life cycle of a generic servlet is the service( ) method. The service
method is called when the server delegates the handling a request to a servlet. A
generic servlet normally overrides the service( ) method to handle a request.

Diagram of a servlet response // adapted from 'Java Servlet Programming', (see refs.)

request  -->    | Web    |    -->      | Servlet's  |
response <--    | Server |    <--      | service( ) |
 

Using doGet( ) and doPost( ) with an HTTP servlet

Using an HTTP servlet a different approach is taken. The service( ) method
is not overidden. Instead the doGet( )  doPost( )  methods are overidden. In
this variation, the service method calls all the doXXX( ) methods and so
is normally not modified in any way. .
 

Diagram of a HTTP Servlet Response  Either GET or POST // from ' Java Servlet Programming'

GET request/response   <->  | Web   |<->| HTTPServlet service( )<-> doGet( )  |
POST request/response <-> | Server |<-> |      "         "         "        <-> doPost( ) |
 

An HTTP servlet has methods for the less commonly used HTTP methods,
including doPut( ), doDelete( ), doHead( ), doTrace( ) and doOptions.

JAX-RPC Uses a Special Form of Servlet

The following servlet 'Hello World' is kept just for interest.

HelloWorld in Servlets

Jason Hunter in his book, 'Java Servlet Programming' figures this is a good point
to introduce 'Hello World' so we do the same. If we may speak, casually, Jason
Hunter is sort of the 'first guru' to Servlets, something like what Danny Goodman
is to JavaScript, Dave Flanagan is to Java. (Dave Flanagan is the writer of 'Java
in a Nutshell').  Jason Hunter is certainly the most vocal supporter of servlets.

// Marty Hall is the  'other first guru'  for servlets and JSPs.

Jason Hunter maintains the servlet site at www.servlets.com and also has a
newletter you can subscribe to. Back to Hello World.
 

Hello World in a Servlet

// from 'Java Servlet Programming', Jason Hunter & William Crawford
// or HelloWorldExample in Tomcat

// trivia courtesy of Jason Hunter: The first 'HelloWorld' was written by Brian
// Kernighan in 1973 while working at Bell on the B programming language.
// B was the precursor to the C programming language. (So was there an A?)
 

Example \tomcat\jakarta-tomcat-3.2\webapps\examples\WEB-INF\classes

Open a browser on the servlet.

Example         http://localhost:8080/examples/servlet/HelloWorld

This too is similar to how Axis allows querying a web service via the
the browser input text field, using URL syntax.

Processing Form Data With Servlets

Servlets become more meaningful when we begin to use them to process form
data. Incoming client data is carried in an HttpServlet in a HttpServletRequest
object. HttpServletRequest is in the first case an interface that itself extends the
ServletRequest interface. ServletRequest defines the methods needed to extract
form data. Following are the signatures of the set of methods that can be used
to process form data.

Following is an HTML page that allows a user to enter some text and press
a submit button to have it processed. The process is set to send the data
to the Hello_Form servlet.
 

HTML Page with a FORM Element

<HTML>
<HEAD>
<TITLE>Hello Form</TITLE>
</HEAD>
<BODY>
<FORM METHOD=GET ACTION="Hello_Form">
Hello! May I ask, who are you?
<INPUT TYPE=TEXT NAME="name"<P>
<INPUT TYPE=SUBMIT>
</FORM>

// The HTTP Protocol is 'commandeered' by SOAP and Web Services
// to supply a different form of message to be sent to the Servlet Container.

Because the GET method is used the data is appended to the URL that will
be sent to the server. If we are running local host the url that is sent will be
something like the following.

Example of a URL sent with a GET

http://localhost:8080/examples/servlet/Hello_Form?name=Billy+the+Kid

// Because Java Web Services are essentially Servlets they can be
// queried in a fashion similar to how the servlet above is being controlled.

The HelloWorld Servlet can be enhanced to provide a dynamic response
to the form submission. The only consequential changes are highlighted in
red. The key call is getParameter( ) which retrieves the parameter that
was appended to the client's GET request.
 

Hello_Form,  A Servlet With a Response to a Form Submission

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class Hello_Form  extends HttpServlet{

public void doGet(HttpServletRequest req, HttpServletResponse res)
                           throws ServletException, IOException{

      res.setContentType("text/html");
      PrintWriter out=res.getWriter( );

    String name=req.getParameter("name");

      out.println("<HTML>");
      out.println("<HEAD><TITLE>Hello_Form</TITLE></HEAD>");
      out.println("<BODY>");
      out.println("<BIG>Hello " + name +  "! </BIG>");
      out.println("</BODY></HTML>");
      }
  }

A final comparison is useful. Following is an excerpt from a JSP note.

Java Server Pages are Transformed into Servlets

While Java Server Pages provide a view or presentation-centric means of
generating servlets there is no escaping that JSPs ultimately execute as servlets.
When a JSP services a request, it does so in it's ultimate ttranslated form, as a
servlet. It is not surprising then, that a discussion of JSP pages still largely involves
related Servlet technology. (This also explains why we spent some time introducing
Servlets.)

JSP_Page .jsp -->   on request is translated to a   ---> Servlet

The Web Service Parallel

JAX-RPC Type Support

• byte  // map to schema types with same names i.e. xs:byte
  
• short
• int
• long
  
• float
• double
• boolean
  

• java.lang.Byte       // same schema mapping as to corresponding primitives
  
• java.lang.Short
• java.lang.Integer 
  
• java.lang.Long
• java.lang.Float
• java.lang.Double
• java.lang.Boolean                                                                                                                                                                                                                       // plus
• java.lang.String            // maps to xs:string
  

• java.math.BigDecimal   // maps to schema xs:decimal
  
• java.math.BigInteger     // maps to schema xs:integer

• Code // code the service endpoint interface & the implementation class
• Build // build, generate & package the service file set
  
• Deploy // deploy the War file in a web server
  

• inteface extends java.rmi.Remote   // or a sub-interface
• methods throw java.rmi.RemoteException // or it's sub-classes
• public fields cannot be marked final  // interface cannot have constants
• parameter and return types must be JAX-RPC types
  

wscompile  syntax

• service // a service description based on a set of endpoint interfaces
• wsdl     // descrbies a WSDL file to import
  
• modelfile  // uses a previously saved model file via the -model option

Configuration file with a WSDL document

wsdeploy -o <output-war-file> <input-war-file> <options> 

• Generated Stubs Proxy // generated from Java service endpoint interfaces or WSDL descriptions
  
• Dynamic Proxy // at runtime the client creates a dynamic stub proxy based on knowledge of WSDL
  
• Dynamic Invocation Interface ( DII) // DII client discovers at runtime service info using a service broker
  

/* Copyright 2002 Sun Microsystems, Inc. All Rights Reserved. 
          See details at end of code sample               */


package hello;

import javax.xml.rpc.Stub;

public class HelloClient {
    public static void main(String[] args) {
        try {
            Stub stub = createProxy();
            stub._setProperty(
                javax.xml.rpc.Stub.ENDPOINT_ADDRESS_PROPERTY,
                args[0]);
            HelloIF hello = (HelloIF)stub;
            System.out.println(hello.sayHello("Duke!"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }    

    private static Stub createProxy() {
        // Note: HelloWorld_Impl is implementation-specific.
        return (Stub)(new HelloWorld_Impl().getHelloIFPort());
    }
}

/*
 *
 * Copyright 2002 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 * 
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 
 * - Redistribution in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials
 *   provided with the distribution.
 * 
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY
 * DAMAGES OR LIABILITIES SUFFERED BY LICENSEE AS A RESULT OF OR
 * RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE OR
 * ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE
 * FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT,
 * SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF
 * THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 * 
 * You acknowledge that this software is not designed, licensed or
 * intended for use in the design, construction, operation or
 * maintenance of any nuclear facility.
 * 
 */