Documente Academic
Documente Profesional
Documente Cultură
Server ™
Deploying an Exploded
J2EE Application
BEA WebLogic Server Version 6.1
Document Date: June 24, 2002
Copyright
Copyright © 2002 BEA Systems, Inc. All Rights Reserved.
1 Deploying an
Exploded J2EE
Application
If you have ever deployed a J2EE application, you know that the process varies among
application servers. The good news is that on WebLogic ServerTM, the process is
automated with tools for professional developers.
This tutorial chapter describes how to use the built-in tools to generate deployment
descriptors, package a sample J2EE application, and deploy it on the server, using the
sample banking application that you can download from the tutorials website. It aims
to teach you enough that you can translate this process to your own applications.
5
1 Deploying an Exploded J2EE Application
The server handles exploded and archived applications the same way, so it is really
your choice which form to use. Deploy your application in exploded form if:
n You want to be able to modify static files (such as JSP or HTML files) while the
application is running on the server without redeploying, using the
WebAppComponentRefreshTool.
n You use WebLogic Server as an application server and another server that has a
different document root (such as the Apache HTTP Server) as a Web server.
n You want to be able to change and recompile enterprise beans and redeploy them
using the hot deploy feature.
However, if your application is final and you want to package it into an EAR file for
ease of deployment or to work as specified in the J2EE Specification, WebLogic
Server fully supports you. The advantage of deploying an archived application are:
If you deploy a web application WAR file and an EJB JAR file separately, the server
loads them in sibling class loaders, in which they don’t have access to each other. This
means that you need to include the EJB interface and stub classes in both archives.
6
Choosing Exploded or Archive Form
EJB Class Loader Web Application Class Loader Web Application Class Loader
But each time you deploy an application EAR file or an exploded application, the
server creates a class loader specifically for that application. The application class
loader is a parent class loader.
All EJB modules in your application are loaded by a single class loader that is a child
of the application class loader. (Note that the terms parent and child do not imply a
superclass/subclass relationship between the class loaders).
Each web module in your application is loaded by its own child class loader. Classes
loaded by a child class loader can see any classes loaded by a parent class loader. This
means that the web modules can see the interface files in the EJB module. What’s
more, the fact that each web module is loaded by its own class loader means that the
web modules can contain files with the same name, such as index.jsp.
Whether you deploy an exploded application or an EAR file, the web application and
enterprise bean modules are part of one application, with aligned class loading, better
performance due to faster RMI calls and use of EJB local interfaces, and isolation from
other applications.
To learn how to deploy an exploded application, stay right here, in this tutorial.
To learn how to package an application into an EAR file, read the chapter J2EE
Packaging and Deployment from the book Java Server Programming, J2EE 1.3
Edition (Wrox Press, 2001).
7
1 Deploying an Exploded J2EE Application
You should set up your application directory to look like Figure 1-2. This uses the
standard J2EE application directory structure.
n Use the same directory structure and deployment descriptors, whether you
deploy in exploded or archive form.
n Develop your application and store its source files in a directory outside the
WebLogic Server directory.
n Use separate directories for the Web application and enterprise bean modules.
This makes it easier to generate the descriptors using the tools and prepares the
directory structure for creating the archive files.
n You can build your application and store the compiled files in the application
directory, deploying them from there if you are testing on a server stored on the
same computer.
8
Step 1: Set Up the Application Directory
Best Practice. Build the WAR, EJB JAR, and EAR packages in separate staging
directories. This gives you separate packages that you can work with if you need to
update and redeploy some classes.
9
1 Deploying an Exploded J2EE Application
If your application has a resource adapter or if you use a standalone Java client
application, you need additional descriptors. Those descriptors, although beyond the
scope of this tutorial, are ra.xml and weblogic-ra.xml for the resource adapter and
application-client.xml and client-application-runtime.xml for the client
application (get more info).
10
The Deployment Descriptors
n Move the JSP files, HTML files, and images to the top level of deploy\web.
Then, compile your enterprise beans to myapp\deploy\ejb. It’s very easy to compile
a number of classes at once with a build script, storing the build script in the
development directory, but compiling the classes to the deployment directory.
Now look at the order in which the classes are compiled. The enterprise bean classes
are compiled before the servlet class, and the servlet needs them for its own
compilation. So, you need to add the location of the compiled enterprise beans to your
CLASSPATH so that BankAppServlet can locate them while it is being compiled.
First, run the setEnv script to set the standard CLASSPATH for compiling applications
for WebLogic Server:
cd WL_HOME\config\mydomain
setEnv
Then, add the relative path from the servlet source file (at banking\dev\web) to the
compiled enterprise bean classes the servlet needs (at banking\ejb\deploy):
set CLASSPATH=..\deploy\ejb;%CLASSPATH%
After adjusting the CLASSPATH, you can run the build script to compile the application
classes to the deployment directory.
11
1 Deploying an Exploded J2EE Application
The DDInit tools generate all the descriptors for an application component, whether
J2EE or WebLogic descriptors. For example, for the web application component, the
tool generates web.xml and weblogic.xml. So even if you are very familiar with how
to write the J2EE descriptors, you should probably either generate them all or write
them all.
In this release (WebLogic Server 6.1), you cannot generate application.xml, the
top-level descriptor for the J2EE application. So, you have two choices:
To use the DDInit tools, just open a command window, move one directory level
above the deployment directory (in our example, that’s banking\deploy, above ejb
and web). Then, enter either of these commands:
java weblogic.ant.taskdefs.war.DDInit directoryName
java weblogic.ant.taskdefs.ejb.DDInit directoryName
The generated descriptors will be stored in the correct WEB-INF and META-INF
directories.
12
Step 2: Generate the Descriptors
Otherwise, you should edit the existing descriptors if you change tables or columns in
your database schema that your application uses. This would affect any application that
uses those tables or columns. You should also edit descriptors to change values that
affect how the server runs your application, such as HTTP session or JSP compilation
parameters.
13
1 Deploying an Exploded J2EE Application
The advantage of using an XML editor is that it tells you which XML elements are
valid at a given point in the file, and then validates the file, telling you where you have
incorrect elements or syntax. This way, you can make sure your descriptors are correct
before you deploy your application.
Figure 1-3 Inserting a Valid XML Element with the BEA XML Editor
t
14
Step 3: Edit the Web Descriptors
Best Practice. Edit deployment descriptors with a tool that parses and validates the
XML. This catches XML syntax errors early and helps you deploy the application
successfully.
Edit web.xml
Now the task is to look at and edit the generated web.xml and weblogic.xml. The
web.xml schema is defined in the Java Servlet Specification 2.3 and in BEA
documentation.
<web-app>
<servlet>
<servlet-name>BankAppServlet</servlet-name>
<servlet-class>examples.tutorials.migration.banking.
15
1 Deploying an Exploded J2EE Application
BankAppServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>error</servlet-name>
<jsp-file>error.jsp</jsp-file>
</servlet>
<servlet>
<servlet-name>AccountDetail</servlet-name>
<jsp-file>AccountDetail.jsp</jsp-file>
</servlet>
<servlet-mapping>
<servlet-name>BankAppServlet</servlet-name>
<url-pattern>/BankAppServlet</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/error</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AccountDetail</servlet-name>
<url-pattern>/AccountDetail</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>login.html</welcome-file>
</welcome-file-list>
<security-constraint>
<display-name></display-name>
<web-resource-collection>
<web-resource-name>My secure resources</web-resource-name>
<description>Resources to be placed under security
control.</description>
<url-pattern>/private/*.jsp</url-pattern>
<url-pattern>/private/*.html</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>guest</role-name>
</auth-constraint>
</security-constraint>
<security-role>
<description>The role allowed to access our
16
Step 3: Edit the Web Descriptors
content</description>
<role-name>guest</role-name>
</security-role>
</web-app>
Listing 1-3 The Edited web.xml for the Sample Banking Application
<web-app>
<welcome-file-list>
<welcome-file>login.html</welcome-file>
</welcome-file-list>
<security-constraint>
<web-resource-collection>
<web-resource-name>My secure resources</web-resource-name>
<description>Resources to be placed under security control.
</description>
<url-pattern>/private/*.jsp</url-pattern>
<url-pattern>/private/*.html</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>guest</role-name>
</auth-constraint>
</security-constraint>
17
1 Deploying an Exploded J2EE Application
<security-role>
<description>The role allowed to access our content
</description>
<role-name>guest</role-name>
</security-role>
</web-app>
Edit weblogic.xml
The weblogic.xml descriptor specifies parameters (in name/value pairs) that describe
information about how the server handles HTTP sessions and JSP compilation for your
application (more info).
In this release, you need to replace the DOCTYPE statement in the generated
weblogic.xml with this one:
This DOCTYPE statement uses the correct version of the DTD, so that your XML editor
can validate the descriptor. The rest of the descriptor can stay the same, unless you
need to edit values for your application.
You can also use the version of weblogic.xml distributed in banking.zip and edit
it for your application.
<weblogic-web-app>
<session-descriptor>
<session-param>
<param-name>URLRewritingEnabled</param-name>
<param-value>true</param-value>
</session-param>
18
Step 3: Edit the Web Descriptors
<session-param>
<param-name>InvalidationIntervalSecs</param-name>
<param-value>60</param-value>
</session-param>
<session-param>
<param-name>PersistentStoreType</param-name>
<param-value>memory</param-value>
</session-param>
<session-param>
<param-name>TimeoutSecs</param-name>
<param-value>3600</param-value>
</session-param>
</session-descriptor>
<jsp-descriptor>
<jsp-param>
<param-name>compileCommand</param-name>
<param-value>javac</param-value>
</jsp-param>
<jsp-param>
<param-name>precompile</param-name>
<param-value>false</param-value>
</jsp-param>
<jsp-param>
<param-name>workingDir</param-name>
<param-value>C:\TEMP\</param-value>
</jsp-param>
<jsp-param>
<param-name>keepgenerated</param-name>
<param-value>true</param-value>
</jsp-param>
<jsp-param>
<param-name>pageCheckSeconds</param-name>
<param-value>5</param-value>
</jsp-param>
</jsp-descriptor>
</weblogic-web-app>
19
1 Deploying an Exploded J2EE Application
They always need values that are specific to your database schema or enterprise beans.
Edit ejb-jar.xml
The elements to look at in ejb-jar.xml (defined in the Enterprise JavaBeans
Specification) are <ejb-name> and <assembly-descriptor>.
To illustrate, Listing 1-5 shows the generated ejb-jar.xml for the sample banking
application.
20
Step 4: Edit the EJB Descriptors
<field-name>accountId</field-name>
</cmp-field>
<cmp-field>
<field-name>balance</field-name>
</cmp-field>
<cmp-field>
<field-name>accountType</field-name>
</cmp-field>
<primkey-field>accountId</primkey-field>
</entity>
</enterprise-beans>
<assembly-descriptor>
</assembly-descriptor>
</ejb-jar>
The value of <ejb-name> is a name for each enterprise bean in your application. The
<ejb-name> value is used only within deployment descriptors, but must match in each
descriptor. It is recommended that you accept the generated <ejb-name>. If you
choose to change it, remember to change it in weblogic-ejb-jar.xml and
weblogic-cmp-rdbms-jar.xml as well.
Notice also that the <assembly-descriptor> element is empty, meaning that it uses
default values for the elements it contains. The empty <assembly-descriptor>
element has this meaning:
<assembly-descriptor>
<container-transaction>
<method>
<description>container managed</description>
<ejb-name>AccountBean</ejb-name>
<method-intf>Remote</method-intf>
<method-name>*</method-name>
</method>
<trans-attribute>Required</trans-attribute>
</container-transaction>
</assembly-descriptor>
For example, you could write <assembly-descriptor> this way if you want to give
the withdraw method a different transaction attribute:
21
1 Deploying an Exploded J2EE Application
<assembly-descriptor>
<container-transaction>
<method>
<description>container managed</description>
<ejb-name>AccountBean</ejb-name>
<method-intf>Remote</method-intf>
<method-name>withdraw</method-name>
</method>
<trans-attribute>Mandatory</trans-attribute>
</container-transaction>
</assembly-descriptor>
Edit weblogic-ejb-jar.xml
The weblogic-ejb-jar.xml descriptor (more info) describes the behavior of your
enterprise beans that is specific to WebLogic Server. weblogic-ejb-jar.xml has
many unique WebLogic elements.
For the sample banking application, and your own applications as well, you need to
look for these elements:
n <type-version>, using the correct version number for your enterprise beans
(either 5.1.0 or 6.0)
With the sample banking application, the ejb.DDInit tool generates the weblogic-
ejb-jar.xml file shown in Listing 1-6.
22
Step 4: Edit the EJB Descriptors
<weblogic-ejb-jar>
<weblogic-enterprise-bean>
<ejb-name>AccountBean</ejb-name>
<entity-descriptor>
<persistence>
<persistence-type>
<type-identifier>WebLogic_CMP_RDBMS</type-identifier>
<type-version>5.1.0</type-version>
<type-storage>META-INF/weblogic-cmp-rdbms-jar.xml
</type-storage>
</persistence-type>
<persistence-use>
<type-identifier>WebLogic_CMP_RDBMS</type-identifier>
<type-version>5.1.0</type-version>
</persistence-use>
</persistence>
</entity-descriptor>
<jndi-name>examples.tutorials.migration.banking.AccountHome
</jndi-name>
</weblogic-enterprise-bean>
</weblogic-ejb-jar>
In this case, we have made no changes to the <ejb-name> in other descriptors, so that
element is fine. The value of <type-version> can be 5.1.0 or 6.0 (in this case, 5.1.0
applies to the beans in the sample application). <type-version> cannot have a value
of 6.1, even if you use WebLogic Server Version 6.1, This makes a difference later,
if you package your EJB component into an EJB JAR file and then use ejbc to verify
the EJB JAR before deploying it on the server.
Then, adjust the value of <jndi-name> to use the <ejb-name> instead of the package
name:
<jndi-name>AccountBean.AccountHome</jndi-name>
So, once edited, the weblogic-ejb-jar.xml file looks like Listing 1-7.
Listing 1-7 The Edited weblogic-ejb-jar.xml for the Sample Banking Application
<weblogic-ejb-jar>
<weblogic-enterprise-bean>
23
1 Deploying an Exploded J2EE Application
<ejb-name>AccountBean</ejb-name>
<entity-descriptor>
<persistence>
<persistence-type>
<type-identifier>WebLogic_CMP_RDBMS</type-identifier>
<type-version>5.1.0</type-version>
<type-storage>META-INF/weblogic-cmp-rdbms-jar.xml
</type-storage>
</persistence-type>
<persistence-use>
<type-identifier>WebLogic_CMP_RDBMS</type-identifier>
<type-version>5.1.0</type-version>
</persistence-use>
</persistence>
</entity-descriptor>
<jndi-name>AccountBean.AccountHome</jndi-name>
</weblogic-enterprise-bean>
</weblogic-ejb-jar>
Edit weblogic-cmp-rdbms-jar.xml
The weblogic-cmp-rdbms-jar.xml descriptor (more info) describes how an entity
bean accesses database tables and columns. This descriptor is generated only for entity
beans, not for session beans.
The main element you should look for in this descriptor is finder (see Listing 1-8).
The finder element describes the finder methods used in the bean and need to be
updated with database queries.
<weblogic-rdbms-jar>
<weblogic-rdbms-bean>
<ejb-name>AccountBean</ejb-name>
24
Step 4: Edit the EJB Descriptors
<pool-name>AccountBeanPool</pool-name>
<table-name>AccountBeanTable</table-name>
<field-map>
<cmp-field>accountId</cmp-field>
<dbms-column>accountIdColumn</dbms-column>
</field-map>
<field-map>
<cmp-field>balance</cmp-field>
<dbms-column>balanceColumn</dbms-column>
</field-map>
<field-map>
<cmp-field>accountType</cmp-field>
<dbms-column>accountTypeColumn</dbms-column>
</field-map>
<finder>
<finder-name>findByPrimaryKey</finder-name>
<finder-param>java.lang.String</finder-param>
<finder-query><![CDATA[(= 1 1)]]></finder-query>
</finder>
<finder>
<finder-name>findAccount</finder-name
<finder-param>double</finder-param>
<finder-query><![CDATA[(= 1 1)]]></finder-query>
</finder>
<finder>
<finder-name>findBigAccounts</finder-name>
<finder-param>double</finder-param>
<finder-query><![CDATA[(= 1 1)]]></finder-query>
</finder>
<finder>
<finder-name>findNullAccounts</finder-name>
<finder-query><![CDATA[(= 1 1)]]></finder-query>
</finder>
</weblogic-rdbms-bean>
</weblogic-rdbms-jar>
The <finder> elements have CDATA attributes that mark blocks of text that would
otherwise be interpreted as markup. Each CDATA attribute needs a database query in
WebLogic Query Language that is specific to your database.
But, if you have a <finder> element for a method named <findByPrimaryKey>, you
can delete it, because the server generates a default query that you should accept in
most cases.
25
1 Deploying an Exploded J2EE Application
<weblogic-rdbms-jar>
<weblogic-rdbms-bean>
<ejb-name>AccountBean</ejb-name>
<pool-name>AccountBeanPool</pool-name>
<table-name>AccountBeanTable</table-name>
<field-map>
<cmp-field>accountId</cmp-field>
<dbms-column>accountIdColumn</dbms-column>
</field-map>
<field-map>
<cmp-field>balance</cmp-field>
<dbms-column>balanceColumn</dbms-column>
</field-map>
<field-map>
<cmp-field>accountType</cmp-field>
<dbms-column>accountTypeColumn</dbms-column>
</field-map>
<finder>
<finder-name>findAccount</finder-name>
<finder-param>double</finder-param>
<finder-query><![CDATA[(= balance $0)]]></finder-query>
</finder>
<finder>
<finder-name>findBigAccounts</finder-name>
<finder-param>double</finder-param>
<finder-query><![CDATA[(> balance $0)]]></finder-query>
</finder>
<finder>
<finder-name>findNullAccounts</finder-name>
<finder-query><![CDATA[(isNull accountType)]]></finder-query>
</finder>
</weblogic-rdbms-bean>
</weblogic-rdbms-jar
26
Step 5: Write application.xml
The main purpose of application.xml is to specify where to locate the web and EJB
modules of your J2EE application. If you are using J2EE 1.2, application.xml must
contain a DOCTYPE definition like this one (all on one line):
<!DOCTYPE application PUBLIC "-//Sun Microsystems, Inc.//DTD J2EE
Application 1.2//EN" "http://java.sun.com/j2ee/dtds/
application_1_2.dtd">
To help you if you need to add elements or add values, the schema for
application.xml is shown in Figure 1-5.
27
1 Deploying an Exploded J2EE Application
application
web-uri context-root?
If you are using the directory structure shown in Figure 1-2 (at the beginning of this
chapter), the application.xml file looks like Listing 1-10 when you deploy your
application in exploded form. It will look different when you package your application
into an EAR file.
<application>
<display-name></display-name>
<module>
<ejb>\ejb</ejb>
</module>
<module>
<web>
<web-uri>\web</web-uri>
<context-root>banking</context-root>
</web>
</module>
28
Step 6: Set Up a Connection Pool
</application>
Note that the value of <context-root> is becomes part of the URL you use to access
the application, after the host and port names, but before the name of the accessed file
or servlet:
http://localhost:7001/banking/login.html
You can set up the connection pool graphically, through the Administration Console,
which adds an entry for your application to the config.xml file in
WL_HOME\config\mydomain.
29
1 Deploying an Exploded J2EE Application
In this step, you leave your application in its development directory, because after
deploying and testing it, you may decide to change source code and recompile. You
are simply deploying by using the Administration Console once the server is running.
Once the application is deployed successfully, you can run it. If it has a Web client,
you would start it from a Web browser, using the value of <context-root> in
application.xml. As an example, you would start the sample banking application
by entering http://localhost:7001/banking/login.html in a Web browser.
30
Step 7: Deploy the Exploded Application
By the way, the valid account numbers you can enter are 1000 and 6000.
Once the application is deployed, decide if and when to redeploy it. You may want to
redeploy often if you are testing, or you may want to protect your application from
being redeployed accidentally.
To control redeployment, create an empty text file named REDEPLOY in the application
META-INF directory. Now you can control redeployment:
n If you modify the file (for example, by adding a space character) or using a
touch command on it (on UNIX systems), you redeploy the application. This is
useful during testing.
31
1 Deploying an Exploded J2EE Application
32
APPENDIX
A Hands-On: Deploying
the Sample Banking
Application
The following sections show you step by step how to deploy the sample banking
application on WebLogic Server.
n Prerequisites
n Set Up the Application Directory
n Generate the Descriptors
n Edit web.xml
n Edit weblogic.xml
n Edit weblogic-ejb-jar.xml
n Edit weblogic-cmp-rdbms-jar.xml
n Edit application.xml
n Insert Cloudscape Data
n Server Startup
n Set Up a Connection Pool
n Configure RMI Logger Startup Class
n Deploy the Exploded Application
Prerequisites
To work through this tutorial, you need:
A-33
A Hands-On: Deploying the Sample Banking Application
The instructions in this tutorial are specific to Microsoft Windows, but can be easily
adapted to UNIX platforms.
Notes
n In the hands-on instructions, a pathname like this
yourWebLogic\config\mydomain
asks you to substitute the name of your WebLogic Server directory for
yourWebLogic.
n When you see bankingHome, it means the root location of the banking
application.
4. Add the location of the compiled EJB classes to your class path:
set CLASSPATH=bankingHome\deploy\ejb;%CLASSPATH%
5. Run the build script to compile the servlet and enterprise bean classes to the
correct locations:
cd bankingHome\dev
build
6. Copy the JSP and HTML files and images to the deploy directory:
cd bankingHome\dev\web
copy images bankingHome\deploy\web
copy html bankingHome\deploy\web
Note that you are moving the JSP and HTML files to deploy\web, not
deploy\web\html.
Edit web.xml
1. With the XML editor of your choice, open
bankingHome\deploy\web\WEB-INF\web.xml.
Edit weblogic.xml
1. Open the generated weblogic.xml in your XML editor.
2. Replace the existing DOCTYPE statement with this one, all on one line:
<!DOCTYPE weblogic-web-app PUBLIC "-//BEA Systems, Inc.//DTD Web
Application 6.1//EN"
"http://www.bea.com/servers/wls610/dtd/weblogic-web-jar.dtd">
Edit weblogic-ejb-jar.xml
1. Open the generated
bankingHome\deploy\ejb\META-INF\weblogic-ejb-jar.xml in your XML
editor.
Edit weblogic-cmp-rdbms-jar.xml
1. Open bankingHome\deploy\ejb\META-INF\weblogic-cmp-rdbms-jar.xml
in your XML editor.
2. Search for findByPrimaryKey. Delete
<finder>findByPrimaryKey</finder>.
<pool-name>demoPool</pool-name>
a. from <dbms-column>accountIdColumn</dbms-column>
to <dbms-column>id</dbms-column>
b. from <dbms-column>balanceColumn</dbms-column>
to <dbms-column>bal</dbms-column>
c. from <dbms-column>accountTypeColumn</dbms-column>
to <dbms-column>type</dbms-column>
6. Search for findAccount and change the value of <finder-query> to:
<![CDATA[(= balance $0)]]>
Edit application.xml
1. Copy the application.xml file included in the zip file to the right location for
deployment:
copy bankingHome\dev\application.xml
bankingHome\deploy\META-INF
If you are using the sample directory structure, you do not need to change
application.xml. The elements would look like this:
<module>
<ejb>\ejb</ejb>
</module>
<module>
<web>
<web-uri>\web</web-uri>
<context-root>banking</context-root>
</web>
2. Add %WL_HOME%\samples\eval\cloudscape\lib\cloudscape.jar to
CLASSPATH.
3. Execute banking.ddl:
java utils.Schema jdbc:cloudscape:%WL_HOME%\samples\eval\cloudscape\data\demo
COM.cloudscape.core.JDBCDriver -verbose bankingHome\dev\ejb\banking.ddl
Server Startup
1. Before starting the server, add the following.
a. To startWebLogic.cmd:
-Dcloudscape.system.home=%WL_HOME%/samples/eval/cloudscape/d
ata
%WL_HOME%\samples\eval\cloudscape\lib\cloudscape.jar;
bankingHome\deploy\ejb
Or, if you specified a different host name or listen port when you installed the
server, use those.
5. NamedemoPool
URLjdbc:cloudscape:demo
Driver ClassnameCOM.cloudscape.core.JDBCDriver
6. Click Create.
ClassName: examples.tutorials.migration.banking.RMILoggerImpl
4. Click Create
6. Click Create.
7. In the left pane, expand banking-exploded. You should see the ejb and web
modules listed beneath it.
10. To start the banking application, open a Web browser and go to this URL:
http://localhost:7001/banking/login.html