Java Technology Home Page
A-Z Index

Java Developer Connection(SM)
Online Training

Downloads, APIs, Documentation
Java Developer Connection
Tutorials, Tech Articles, Training
Online Support
Community Discussion
News & Events from Everywhere
Products from Everywhere
How Java Technology is Used Worldwide
Print Button
 
Training Index | J2EE Index | J2EE Tech Center

Lesson 1
A Simple Session Bean

[<<BACK] [CONTENTS] [NEXT>>]

This lesson introduces you to J2EE applications programming, and the J2EE SDK by showing you how to write a simple thin-client multitiered enterprise application that consists of an HTML page, servlet, and session bean.

The J2EE SDK is a non-commercial operational definition of the J2EE platform and specification made freely available by Sun Microsystems for demonstrations, prototyping, and educational uses. It comes with the J2EE application server, Web server, database, J2EE APIs, and a full-range of development and deployment tools. You will become acquainted with many of these features and tools as you work through the lessons in this tutorial.

Example Thin-Client Multitiered Application

The example thin-client multitiered application for this lesson accepts user input through an HTML form that invokes a servlet. The servlet uses Java Naming and Directory Interface™ (JNDI) APIs to look up a session bean to perform a calculation on its behalf. Upon receiving the results of the calculation, the servlet returns the calculated value to the end user in an HTML page.

This example is a thin-client application because the servlet does not execute any business logic. The simple calculation is performed by a session bean executing on the J2EE application server. So, the client is thin because it does not handle the processing; the session bean does.

Multitiered applications can consist of 3 or 4 tiers. As shown in Figure 1, the multitiered example for this tutorial has four tiers. Three-tiered architecture extends the standard two-tier client and server model by placing a multithreaded application server between the non-web-based client application and a backend database. Four-tiered architecture extends the three-tier model by replacing the client application with a Web browser and HTML pages powered by servlet/JavaServer Pages™ technology.

 

Multitiered Architecture

While this lesson uses only three of the four tiers, Lesson 2 expands this same example to access the database server in the fourth tier. Later lessons adapt the example to use JavaServer™ Pages and Extensible Markup Language (XML) technologies.

J2EE Software and Setup

To run the tutorial examples, you need to download and install the Java 2 SDK Enterprise Edition (J2EE), Version 1.2.1 Release ( http://java.sun.com/j2ee/download.html ), and Java 2 SDK, Standard Edition (J2SE), Version 1.2 or later ( http://java.sun.com/jdk/index.html ).

The instructions in this tutorial assume J2EE and J2SE are both installed in a J2EE directory under monicap's home directory.

Note: Everywhere monicap is used in a path name, please change it to your own user name.

Unix:

/home/monicap/J2EE/j2sdkee1.2.1
/home/monicap/J2EE/jdk1.2.2

Windows:

\home\monicap\J2EE\j2sdkee1.2.1
\home\monicap\J2EE\jdk1.2.2

Path and ClassPath Settings

The download has the J2EE application server, Cloudscape database, a Web server using secure socket layer (SSL) also known as HTTP over HTTPS, development and deployment tools, and the Java APIs for the Enterprise. To use these features, set your path and class path environment variables as described here.

Path Settings

Path settings make the development and deployment tools accessible from anywhere on your system. Make sure you place these path settings before any other paths you might have for other older JDK installations.

Unix:

/home/monicap/J2EE/jdk1.2.2/bin
/home/monicap/J2EE/j2sdkee1.2.1/bin

Windows:

\home\monicap\J2EE\jdk1.2.2\bin
\home\monicap\J2EE\j2sdkee1.2.1\bin

Class Path Settings

Class path settings tell the Java 2 development and deployment tools where to find the various class libraries they use.

Unix:

/home/monicap/J2EE/j2sdkee1.2.1/lib/j2ee.jar

Windows:

\home\monicap\J2EE\j2sdkee1.2.1\lib\j2ee.jar

J2EE Application Components

J2EE applications programmers write J2EE application components. A J2EE component is a self-contained functional software unit that is assesmbled into a J2EE application and interfaces with other application components. The J2EE specification defines the following application components:

  • Application client components
  • Enterprise JavaBeans components
  • Servlets and JavaServer Pages components (also called Web components)
  • Applets

In this lesson, you create a J2EE application and two J2EE components: a servlet and session bean. The servlet is bundled with its HTML file into a Web Archive (WAR) file, and the session bean interfaces and classes are bundled into a JAR file. The WAR and JAR files are added to the J2EE application and bundled into an Enterprise Archive (EAR) file for verification testing and deployment to the production environment.

While you do all of these steps for this lesson, you are actually performing several different functions. Writing the servlet and session bean code is a developer function, while creating a J2EE application and adding J2EE components to an application assembly function. In reality, these functions would be performed by different people in different companies.

Create the HTML Page

The HTML page for this lesson is called bonus.html . It's HTML code is after Figure 2, which shows how the HTML page looks when displayed to the user. The bonus.html file has two data fields so the user can enter a social security number and a multiplier. When the user clicks the Submit button, BonusServlet retrieves the end user data, looks up the session bean, and passes the user data to the session bean. The session bean calculates a bonus and returns the bonus value to the servlet. The servlet then returns another HTML page with the bonus value for the end user to view.

 

HTML Page

Figure 3 shows how data flows between the browser and the session bean. The session bean executes in the J2EE application server.

 

Data Flow

HTML Code

The interesting thing about the HTML form code is the alias used to invoke BonusServlet . When the user clicks the Submit button on the HTML form, BonusServlet is invoked because it is mapped to the BonusAlias during application assembly described in Assemble the J2EE Application.

The example assumes bonus.html is in the /home/monicap/J2EE/ClientCode directory on Unix. Here and hereafter, Windows users can reverse the slashes to get the correct directory pathname for their platform.

<HTML>
<BODY BGCOLOR = "WHITE">
<BLOCKQUOTE>
<H3>Bonus Calculation</H3>
<FORM METHOD="GET" 
       ACTION="BonusAlias">
<P>
Enter social security Number:
<P>
<INPUT TYPE="TEXT" NAME="SOCSEC"></INPUT>
<P>
Enter Multiplier:
<P>
<INPUT TYPE="TEXT" NAME="MULTIPLIER"></INPUT>
<P>
<INPUT TYPE="SUBMIT" VALUE="Submit">
<INPUT TYPE="RESET">
</FORM>
</BLOCKQUOTE>
</BODY>
</HTML>

Create the Servlet

The example assumes the BonusServlet.java file is in the /home/monicap/J2EE/ClientCode directory on Unix. At run time, the servlet code does the following:

  • Retrieves the user data
  • Looks up the session bean
  • Passes the data to the session bean
  • Upon receiving a value back from the session bean, creates an HTML page to display the returned value to the user.

The next sections describe the different parts of the servlet code. The servlet code is shown in its entirety in Servlet Code.

Import Statements

The servlet code begins with import statements for the following packages:

  • javax.servlet , which contains generic (protocol-independent) servlet classes. The HTTPServlet class uses the ServletException class in this package to indicate a servlet problem.
  • javax.servlet.http , which contains HTTP servlet classes. The HttpServlet class is in this package.
  • java.io for system input and output. The HttpServlet class uses the IOException class in this package to signal that an input or output exception of some kind has occurred.
  • javax.naming for using the Java Naming and Directory Interface (JNDI™) APIs to look up the session bean home interface.
  • javax.rmi for looking up the session bean home interface and making its remote server object ready for communications.

init Method

The BonusServlet.init method looks up the session bean home interface and creates its instance. The method uses the JNDI name specified during component assembly ( calcs ) to get a reference to the home interface by its name. The next line passes the reference and the home interface class to the PortableRemoteObject.narrow method to be sure the reference can be cast to type CalcHome .

InitialContext ctx = new InitialContext();
Object objref = ctx.lookup("calcs");
homecalc = (CalcHome)PortableRemoteObject.narrow(obj 
            ref, CalcHome.class);

doGet Method

The parameter list for the doGet method takes a request and response object. The browser sends a request to the servlet and the servlet sends a response back to the browser. The method implementation accesses information in the request object to find out who made the request, what form the request data is in, and which HTTP headers were sent, and uses the response object to create an HTML page in response to the browser's request.

The doGet method throws an IOException if there is an input or output problem when it handles the request, and a ServletException if the request could not be handled. To calculate the bonus value, the doGet method creates the home interface and calls its calcBonus method.

  public void doGet (HttpServletRequest request,
                     HttpServletResponse response)
               throws ServletException, IOException {
    String socsec = null;
    int multiplier = 0;
    double calc = 0.0;
    PrintWriter out;
    response.setContentType("text/html");
    String title = "EJB Example";
    out = response.getWriter();
    out.println("<HTML><HEAD><TITLE>)
    out.println(title);
    out.println("</TITLE></HEAD><BODY>");

    try{
//Retrieve Bonus and Social Security Information
      String strMult = request.getParameter(
                       "MULTIPLIER");
      Integer integerMult = new Integer(strMult);
      multiplier = integerMult.intValue();
      socsec = request.getParameter("SOCSEC");

//Calculate  bonus
      double bonus = 100.00;
      theCalculation = homecalc.create();
      calc = theCalculation.calcBonus(
             multiplier, bonus);
    }catch(Exception CreateException){
      CreateException.printStackTrace();
    }

//Display Data
    out.println("<H1>Bonus Calculation</H1>");
     out.println("<P>Soc Sec: " + socsec + "<P>");
    out.println("<P>Multiplier: " + 
                multiplier + "<P>");
    out.println("<P>Bonus Amount: " + calc + "<P>");
    out.println("</BODY></HTML>");
    out.close();
  }

Servlet Code

Here is the full code.

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import javax.naming.*;
import javax.rmi.PortableRemoteObject;
import Beans.*;

public class BonusServlet extends HttpServlet {
  CalcHome homecalc;

  public void init(ServletConfig config) 
		throws ServletException{

//Look up home interface
    try{
      InitialContext ctx = new InitialContext();
      Object objref = ctx.lookup("calcs");
      homecalc = 
              (CalcHome)PortableRemoteObject.narrow(
      objref, 
      CalcHome.class);
    } catch (Exception NamingException) {
      NamingException.printStackTrace();
    }
  }
  public void doGet (HttpServletRequest request, 
      HttpServletResponse response) 
      throws ServletException, IOException {
    String socsec = null;
    int multiplier = 0;
    double calc = 0.0;
    PrintWriter out;
    response.setContentType("text/html");
    String title = "EJB Example";
    out = response.getWriter();
    out.println("<HTML><HEAD><TITLE>");
    out.println(title);
    out.println("</TITLE></HEAD><BODY>");
    try{
      Calc theCalculation;
//Get Multiplier and Social Security Information
      String strMult = 
        request.getParameter("MULTIPLIER");
      Integer integerMult = new Integer(strMult);
      multiplier = integerMult.intValue();
      socsec = request.getParameter("SOCSEC");
//Calculate bonus
      double bonus = 100.00;
      theCalculation = homecalc.create();
      calc = 
         theCalculation.calcBonus(multiplier, bonus);
    } catch(Exception CreateException){
      CreateException.printStackTrace();
    }
//Display Data
    out.println("<H1>Bonus Calculation</H1>");
    out.println("<P>Soc Sec: " + socsec + "<P>");
    out.println("<P>Multiplier: " + 
                multiplier + "<P>");
    out.println("<P>Bonus Amount: " + calc + "<P>");
    out.println("</BODY></HTML>");
    out.close();
  }
  public void destroy() {
    System.out.println("Destroy");
  }
}

Create the Session Bean

A session bean represents a transient conversation with a client. If the server or client crashes, the session bean and its data are gone. In contrast, entity beans are persistent and represent data in a database. If the server or client crashes, the underlying services ensure the entity bean data is saved.

Because the enterprise bean performs a simple calculation at the request of BonusServlet, and the calculation can be reinitiated in the event of a crash, it makes sense to use a session bean in this example.

Figure 4 shows how the servlet and session bean application components work as a complete J2EE application once they are assembled and deployed. The container, shown in the shaded box, is the interface between the session bean and the low-level platform-specific functionality that supports the session bean. The container is created during deployment.

 

Application Components

The next sections show the session bean code. The example assumes the CalcBean.java , Calc.java , and CalcHome.java files are placed in the /home/monicap/J2EE/Beans directory on Unix. The package Beans statement at the top of the CalcBean interface and class files is the same name as the name of this directory. When these files are compiled, they are compiled from the directory above Beans and the Beans package (or directory) name is prepended with a slash to the interface and class files being compiled. Compile the Session Bean.

Note: While this example shows how to write the example session bean, it is also possible to purchase enterprise beans from a provider and assemble them into a J2EE application.

CalcHome

BonusServlet does not work directly with the session bean, but creates an instance of its home interface. The home interface extends EJBHome and has a create method for creating the session bean in its container. CreateException is thrown if the session bean cannot be created, and RemoteException is thrown if a communications-related exception occurs during the execution of a remote method.

package Beans;

import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;

public interface CalcHome extends EJBHome {
  Calc create() throws CreateException, 
                RemoteException;
}

Calc

When the home interface is created, the J2EE application server creates the remote interface and session bean. The remote interface extends EJBObject and declares the calcBonus method for calculating the bonus value. This method is required to throw javax.rmi.RemoteException , and is implemented by the CalcBean class.

package Beans;

import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Calc extends EJBObject {
  public double calcBonus(int multiplier,
                          double bonus)
                     throws RemoteException;
}

CalcBean

The session bean class implements the SessionBean interface and provides behavior for the calcBonus method. The setSessionContext and ejbCreate methods are called in that order by the container after BonusServlet calls the create method in CalcHome.

The empty methods are from the SessionBean interface. These methods are called by the bean's container. You do not have to provide behavior for these methods unless you need additional functionality when the bean is, for example, created or removed from its container.

package Beans;

import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

public class CalcBean implements SessionBean {
  public double calcBonus(int multiplier,
                         double bonus) {
    double calc = (multiplier*bonus);
    return calc;
  }
//These methods are described in more
//detail in Lesson 2
  public void ejbCreate() { }
  public void setSessionContext(
      SessionContext ctx) { }
  public void ejbRemove() { }
  public void ejbActivate() { }
  public void ejbPassivate() { }
  public void ejbLoad() { }
  public void ejbStore() { }
}

Compile the Session Bean and Servlet

To save on typing, the easiest way to compile the session bean and servlet code is with a script (on Unix) or a batch file (on Windows).

Compile the Session Bean

Unix

#!/bin/sh
cd /home/monicap/J2EE
J2EE_HOME=/home/monicap/J2EE/j2sdkee1.2.1
CPATH=.:$J2EE_HOME/lib/j2ee.jar
javac -d . -classpath "$CPATH" Beans/CalcBean.java
            Beans/CalcHome.java Beans/Calc.java 

Windows

cd \home\monicap\J2EE
set J2EE_HOME=\home\monicap\J2EE\j2sdkee1.2.1
set CPATH=.;%J2EE_HOME%\lib\j2ee.jar
javac -d . -classpath %CPATH% Beans/CalcBean.java
            Beans/CalcHome.java Beans/Calc.java 

Compile the Servlet

Unix

#!/bin/sh
cd /home/monicap/J2EE/ClientCode 
J2EE_HOME=/home/monicap/J2EE/j2sdkee1.2.1
CPATH=.:$J2EE_HOME/lib/j2ee.jar:
      /home/monicap/J2EE
javac -d . -classpath "$CPATH" BonusServlet.java 

Windows

cd \home\monicap\J2EE\ClientCode 
set J2EE_HOME=\home\monicap\J2EE\j2sdkee1.2
set CPATH=.;%J2EE_HOME%\lib\j2ee.jar;
  \home\monicap\J2EE
javac -d . -classpath %CPATH% BonusServlet.java

Start the J2EE Application Server

You need to start the J2EE application server to deploy and run the example. The command to start the server is in the bin directory under your J2EE installation. If you have your path set to read the bin directory, go to the J2EE directory (so your live version matches what you see in this text) and type:

j2ee -verbose
Note: Sometimes the J2EE server will not start if Outlook is running.

If that does not work, type the following from the J2EE directory:

Unix:

j2sdkee1.2.1/bin/j2ee -verbose

Windows:

j2sdkee1.2.1\bin\j2ee -verbose

The verbose option prints informational messages to the command line as the server starts up. When you see J2EE server startup complete , you can start the depoloyer tool. For now, you can ignore the other messages that scrolled by.

Start the Deploy Tool

To assemble and deploy the J2EE application, you have to start the deploy tool. If you have your path set to read the bin directory, go to the J2EE directory (so your live version matches what you see in this text) and type:

deploytool

If that does not work, do the following from the J2EE directory:

Unix:

j2sdkee1.2.1/bin/deploytool

Windows:

j2sdkee1.2.1\bin\deploytool
Notes: If a memory access error is encountered when starting deploytool , add an environment variable called JAVA_FONTS and set the path to c: \<font directory> . For example c:\winnt\fonts . Also, If a NullPointerException for BasicFileChooserUI is encountered when starting deploytool , be sure you are not starting the tool from the root directory (i.e. c:\ ). If you run it somewhere else, such as the bin directory for your j2sdkee1.2 installation, you will not encounter the problem.

Deploy Tool

The Deploy tool shown in Figure 5 has four main windows. The Local Applications window displays J2EE applications and their components. The Inspecting window displays information on the selected application or components. The Servers window tells you the application server is running on the local host. And the Server Applications window tells you which applications have been installed. As you go through the steps to assemble the example J2EE application, you will see the Local Applications, Inspecting, and Server Applications windows display information.

 

Deploy Tool
Note: To the right of the Server Applications window is a grayed Uninstall button. After you deploy the application, you will see the application listed in the Server Applications window. You can click Uninstall to uninstall the application, make changes, and redeploy it without having to stop and restart the application server.

Assemble the J2EE Application

Assembling a J2EE application involves creating a new application, and adding the application components to it. Here is a summary of the assembly steps, which are discussed in more detail below.

  1. Create a new J2EE application ( BonusApp.ear ).
  2. Create a new enterprise bean ( CalcBean.jar ).
  3. Create a new web component ( Bonus.war ).
  4. Specify JNDI name for the enterprise bean ( calcs ).
  5. Specify the Root Context for the J2EE application ( BonusRoot ).

Create J2EE Application

J2EE components are assembled into J2EE application Enterprise Archive (EAR) files.

File menu : Select New Application .

New Application dialog box,:

  • Type BonusApp.ear for the Application File Name .
  • Click the right mouse button in the Application Display Name field. BonusApp appears as the display name.
  • Click the Browse button to open the file chooser to select the location where you want the application EAR file to be saved.

New Application file chooser:

  • Locate the directory where you want to place the application EAR file
  • In this example, that directory is /home/monicap/J2EE .
  • In the File name field, type BonusApp.ear.
  • Click New Application .
  • Click OK .

The BonusApp display name is now listed in the Local Applications window, and the Inspector window to the right shows the display name, location, and contents information for BonusApp . The meta information shown in the contents window describes the JAR file and J2EE application, and provides runtime information about the application.

Create Session Bean

Enterprise beans (entity and session beans) are bundled into a Java Archive (JAR) file.

File menu : Select New Enterprise Bean . The New Enterprise Bean Wizard starts and displays an Introduction dialog box that summarizes the steps you are about to take. After reading it over, click Next .

EJB JAR dialog box: Specify the following information:

  • Enterprise Bean will go in : BonusApp
    Display name: CalcJar
    Description: A simple session bean that
    calculates a bonus. It has one method
  • Click Add . There are two Add buttons on this screen. Make sure you click the second one down that is next to the Contents window.

Add Files to .JAR dialog box: go to the J2EE directory. You can either type the path name or use the browser to get there. Once at the J2EE directory, double click on beans to display the contents of the beans directory.

  • Select Calc.class .
  • Click Add .
  • Select CalcHome.class .
  • Click Add .
  • Select CalcBean.class .
  • Click Add .
Important Note: The Add Contents to .JAR dialog box should look like the one in Figure 6. The Enterprise Bean JAR classes must show the Beans directory prefixed to the class names.

 

Select Session Bean Class Files
  • Click OK. You should now be back at the EJB JAR dialog box. Beans/Calc.class , Beans/CalcHome.class , and Beans/CalcBean.class should appear in the Contents window.
  • Click Next.

General dialog box: Make sure the following information is selected:

  • classname: Beans.CalcBean
    Home interface:
    Beans.CalcHome
    Remote interface:
    Beans.Calc
    Bean type:
    Session and Stateless
  • Specify the display name (the name that appears when when the JAR file is added to BonusApp in the Local Applications window), and provide a description of the JAR file contents.
  • Display Name: CalcBean
  • Description: This JAR file contains the CalcBean session bean.
  • Click Next .

Environment Entries dialog box: This example does not use properties (environment entries) so you can:

  • Click Finish .

Verify the JAR file was indeed added to the J2EE application:

  • Go to the Local Applications window
  • Click the key graphic in front of the BonusApp . You will see the CalcJar JAR file.
  • Click the key graphic in front of the CalcJar to see the CalcBean session bean.

Create Web Component

Web components (servlets, or JavaServer Pages™ technology) are bundled into a Web Archive (WAR) file.

File menu : Select New Web Component . The New Web Component Wizard starts and displays a window that summarizes the steps you are about to take. After reading it over, click Next .

WAR File General Properties dialog box : Provide the following information:

  • WAR file: BonusApp
    Display name: BonusWar
    Description: This war file contains a servlet and an html page.
  • Click Add .

Add Contents to WAR dialog box:

  • Go to the ClientCode directory by typing ClientCode after J2EE in the Root Directory field.
  • Select bonus.html. Make sure the WAR contents shows the listing as bonus.html without the ClientCode directory prefixed to the name.
  • Click Add .
Note : Make sure you add bonus.html before you add BonusServlet.class

 

Add BonusServlet.class
  • Click Next .
  • Choose the ClientCode directory again.
  • Select BonusServlet.class. Be sure the WAR contents shows the listing as BonusServlet.class without the ClientCode directory prefixed to the name.
  • Click Add .

Add Contents to WAR dialog box: The display should look like Figure 8.

 

Add bonus.html
  • Click Finish .

WAR File General Properties dialog box:

  • Click Next .

Choose Component Type dialog box:

  • Select Servlet (if it is not already selected)
  • Click Next .

Component General Properties dialog box:

  • Make sure BonusServlet is selected for the Servlet Class .
  • Enter a display name ( BonusServlet ) and description.
  • You can ignore the Startup and load sequence settings here because this example uses only one servlet.

Component Initialization Parameters dialog box:

  • Click Next . BonusServlet does not use any initialization parameters.

Component Aliases dialog box:

  • Click Add .
  • Type BonusAlias and press Return . This is the same alias name you put in the ACTION field of the HTML form embedded in the bonus.html file.
  • Click Finish .

In the Content pane, you can see that the WAR file contains an XML file with structural and attribute information on the web application, the bonus.html file, and the BonusServlet class file. The WAR file format is such that all servlet classes go in an entry starting with Web-INF/classes . However, when the WAR file is deployed, the BonusServlet class is placed in a Context Root directory under public_html . This placement is the convention for Servlet 2.2 compliant web servers.

To change the display name or description:

  • Put your cursor in the appropriate field in the window
  • Change them as you wish.
  • Press the Return key for the edits to take effect.

Specify JNDI Name and Root Context

Before you can deploy the BonusApp application and its components, you have to specify the JNDI name BonusServlet uses to look up the CalcBean session bean, and specify a context root directory where the deployer will put the web components.

JNDI Name:

  • Select the BonusApp file in the Local Applications window. The Inspecting window displays tabs at the top, and one of those tabs is JNDI Names.
  • Select JNDI Names. The Inspecting window shows a three-column display with one row. CalcBean is listed in the middle column.
  • In the far right column under JNDI name, type calcs. This JNDI name is the same JNDI name passed to the BonusServlet.lookup method.
  • Press the Return key.

Context Root:

  • Click the Web Context tab at the top of the Inspecting window. You will see BonusWar in the left column.
  • Type BonusRoot in the right column
  • Press the Return key. During deployment the BonusRoot directory is created under the public_html directory in your J2sdkee1.2 installation, and the bonus.html file and BonusServlet class are copied into it as shown in Figure 9.

 

Context Root Directory Structure

Aliases:

  • In the LocalApp window, click BonusWar and then click BonusServlet
  • Click the Aliases tab at the top of the Inspecting window. You should see BonusAlias in the field.
  • If BonusAlias is not there, type it in and press Return .

Verify and Deploy the J2EE Application

Before you deploy the application, it is a good idea to run the verifier. The verifier will pick up errors in the application components such as missing enterprise bean methods that the compiler does not catch.

Verify:

  • With BonusApp selected, choose Verifier from the Tools menu.
  • In the dialog that pops up, click OK . The window should tell you there were no failed tests.
  • Close the verifier window because you are now ready to deploy the application.
Note: In the Version 1.2 software you might get a tests app.WebURI error. This means the deploy tool did not put a .war extension on the WAR file during WAR file creation. This is a minor bug and the J2EE application deploys just fine in spite of it.

Deploy:

  • From the Tools menu, choose Deploy Application . A Deploy BonusApp dialog box pops up. Verify that the Target Server selection is either localhost or the name of the host running the J2EE server.
Note: Do not check the Return Client Jar box. The only time you need to check this box is when you deploy a stand-alone application for the client program. This example uses a servlet and HTML page so this box should not be checked. Checking this box creates a JAR file with the deployment information needed by a stand-alone application.
  • Click Next . Make sure the JNDI name shows calcs . If it does not, type it in yourself, and press the Return key.
  • Click Next . Make sure the Context Root name shows BonusRoot . If it does not, type it in yourself and press the Return key.
  • Click Next .
  • Click Finish to start the deployment. A dialog box pops up that displays the status of the deployment operation.
  • When it is complete, the three bars on the left will be completely shaded as shown in Figure 10. When that happens, click OK .

 

Deploy Application

Run the J2EE Application

The web server runs on port 8000 by default. To open the bonus.html page point your browser to http://localhost:8000/BonusRoot/bonus.html , which is where the Deploy tool put the HTML file.

Note: If you need to use a different port because port 8000 is being used for something else, edit the web.properties file in the ~/J2EE/j2sdkee1.2/config directory and restart the J2EE server.
  • Fill in a social security number
  • Fill in a multiplier
  • Click the Submit button. BonusServlet processes your data and returns an HTML page with the bonus calculation on it.
Bonus Calculation

Soc Sec: 777777777
Multiplier: 25

Bonus Amount 2500.0

Updating Component Code

The Tools menu has two menu options of interest. they are Update Application Files and Update and Redeploy Application . These options let you change code and redeploy your application with ease. Simply make your code changes, recompile the code, and choose one of these menu options.

  • Update Application Files updates the application files with your new code. At this point you can either verify the application again or deploy it.
  • Update and Redeploy Application updates the application files with your new code and redeployes the application without running the verifier.

[TOP]


Print Button
[ This page was updated: 27-Sep-2000 ]
Products & APIs | Developer Connection | Docs & Training | Online Support
Community Discussion | Industry News | Solutions Marketplace | Case Studies
Glossary | Feedback | A-Z Index
For more information on Java technology
and other software from Sun Microsystems, call:
(800) 786-7638
Outside the U.S. and Canada, dial your country's AT&T Direct Access Number first.
Sun Microsystems, Inc.
Copyright © 1995-2000 Sun Microsystems, Inc.
All Rights Reserved. Terms of Use. Privacy Policy.