THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
Overview
A typical J2EE application may contain Enterprise JavaBeans or EJBs. These beans contain the application's business logic and live business data. Although it is possible to use standard Java objects to contain your business logic and business data, using EJBs addresses many of the issues of using simple Java objects, such as scalability, lifecycle management and state management.
This document discusses one type of EJB, the Session EJB. This type of EJB is useful for mapping business process flow (or equivalent application concepts). There are two types of Session EJB, stateless and stateful.
EJBs hold conversations with clients. A conversation is basically an interaction between the EJB and the client and these interactions are composed of method calls by the clients to the EJBs. Stateful session beans retain state on behalf of a client. This means that if the state of the bean changes during a client's method call, this state is retained for subsequent calls by the same client. A stateless session bean on the other hand retains no conversational state from method to method. In other words, it is expected to hold its conversational state for only a single method call.
This article is organized in the following sections:
- Session Beans implementation analysis
- Sample application
- The JBoss environment
- The Geronimo environment
- Step-by-step migration
- Summary
Session Beans implementation analysis
EJB implementation may vary from one vendor to another. The purpose of this section is to provide a session bean specific feature-to-feature comparison between JBoss and Apache Geronimo so you can clearly identify the differences and plan accordingly before migration.
Sample application
This sample application shows how session beans are used and deployed in a container. There are two clients, one for stateless session beans and another for stateful session beans. Both client applications use the same database which contains a table that stores loan application details. An entity bean is used to connect to and operate on the loan details table. A session bean is then used by the client application to get specific details from the database using the entity bean. The first client creates a stateless session bean and displays a list of denied loan applications via a method defined in that EJB. The second client creates a stateful session bean and adds loan applications to the database.
The following figure illustrates the application flow:
Application Beans
The session bean sample application consists of the following packages:
- com.ibm.demo.entity
- CustomerBean - contains the methods that connect to the database and operations to manipulate the data.
- CustomerHomeRemote - the remote interface for the EJB.
- CustomerHomeRemote - EJBHome Interface.
- com.ibm.demo.session.stateful
- StatefulLoanManagerBean - it has the submitLoanApplication() method that saves new customer loan applications to the database as well as the getSubmitCount() method that returns the number of loans submitted; since this bean is a stateful session bean, it can remember connection details from a session so the loan application submit count is retained for every call to the submitLoanApplication() method.
- StatefulLoanManagerRemote - the remote interface for the EJB.
- StatefulLoanManagerHomeRemote - EJBHome Interface.
- com.ibm.demo.session.stateless
- LoanManagerBean -it has the deniedLoans() method that is used to get a list of all customers whose loan applications are denied based on the condition that their Annual Salary to Loan Amount ratio is less than 0.1
- LoanManagerRemote - the remote interface for the EJB.
- LoanManagerHomeRemote - EJBHome Interface.
Tools used
The tools used for developing and building all the applications are:
Eclipse with JBoss IDE
The Eclipse with JBoss IDE plug-ins was used for development of Java-source code of the sample applications. Eclipse is a very powerful and popular open source development tool. Eclipse can be downloaded from the following URL:
Apache Maven
Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM). Maven can manage a project's build, reporting and documentation from a central piece of information.
For this migration example Maven 1.0.2 was used. Maven can be downloaded from the followinf URL:
Sample database
The sample database for the MDB sample application has only one table. This is an in-memory table. The MEMORY storage engine creates tables with contents that are stored in just in memory. These were formerly known as HEAP tables.
The following table describes the fields of the CUSTOMER table.
Field |
data type |
|---|---|
id |
INTEGER |
name |
VARCHAR(45) |
birthdate |
DATE |
sss_no |
VARCHAR(25) |
address |
VARCHAR(60) |
annual_salary |
DOUBLE |
loan_amount |
DOUBLE |
The JBoss environment
This section shows you how and where the sample JBoss reference environment was installed so you can map this scenario to your own implementation. Note that for this migration example JBoss v4.0.2 was used.
Detailed instructions for installing, configuring, and managing JBoss are provided in the product documentation. Check the product Web site for the most updated documents.
The following list highlights the general tasks you will need to complete to install and configure the initial environment as the starting point for deploying the sample application.
- Download and install JBoss v4 as explained in the product documentation guides. From now on the installation directory will be referred as <jboss_home>
- Create a copy of the default JBoss v4 application server. Copy recursively <jboss_home>\server\default to <jboss_home>\server\<your_server_name>
- Start the new server by running the
run.sh -c <your_server_name>command from the <jboss_home>\bin directory. - Once the server is started, you can verify that it is running by opening a Web browser and pointing it to this URL: http://localhost:8080. You should see the JBoss Welcome window and be able to access the JBoss console.
- Once the application server is up and running, the next step is to install and configure all the remaining prerequisite software required by the sample application. This step is described in the following section.
Install and configure prerequisite software
In order to build and run the Loan BMP application included in this article, you need to install and configure the build tool and the database that is used by the application.
Modify database settings
This application is using the HSQL database that comes as part of the JBoss bundle. You need to modify the script for creating the database. Edit the localDB.script file located in the following directory:
<jboss_home>\server\<your_server_name>\data\hypersonic
Add at the top of the localDB.script file the content of the following example in order to create the sample HSQL database.
Make sure JBoss is not running at the time of modifying this file.
CREATE MEMORY TABLE CUSTOMER(ID INTEGER NOT NULL PRIMARY KEY,NAME VARCHAR(45),BIRTHDATE DATE,SSS_NO VARCHAR(25),ADDRESS VARCHAR(60),ANNUAL_SALARY DOUBLE,LOAN_AMOUNT DOUBLE)
Configure Maven
As mentioned before, Apache Maven is used to build the binaries for the Loan BMP application. If you do not have Maven installed this is a good time for doing it.
Apache Maven can be downloaded from the following URL:
Build the sample application
In order to build the Session Bean application a Maven script has been provided. Download the Session Bean sample application from the following URL:
http://opensource2.atlassian.com/confluence/oss/download/attachments/1155/session.zip
After extracting the zip file, a session directory will be created. From now on, this directory will be referred as <session_home>. In that directory open the project.properties file. Edit the maven.jboss.home property to match your environment.
build.properties
maven.ejb.includes=com/ibm/demo/entity/**, com/ibm/demo/session/** maven.ejb.excludes=com/ibm/demo/client/** maven.ejb.src=dd maven.jboss.home=<jboss_home> maven.geronimo.home=<geronimo_home>
This sample application requires some jars provided by Geronimo, if you do not have Geronimo installed refer to The Geronimo environment section for installation guidance
From a command prompt or shell go to the <bmp_home> directory and run the following command:
maven
This will compile the source files and package the EJB jar file. You can see the results in the <session_home>/target directory. The following list shows the dependency jars needed in building and running the Session Bean sample application.
- geronimo-spec-ejb-2.1-rc4.jar - the EJB spec; needed for compiling source.
- openejb-core-2.0-G1M5.jar - needed by Geronimo during runtime.
- geronimo-spec-j2ee-1.4-rc4.jar - needed by Geronimo during runtime.
- geronimo-security-1.0-M5.jar - needed by Geronimo during runtime.
Note that JBoss doesn't need the last three jars to run the application.
Deploy the sample application
To deploy the Session Bean sample application you just built with Maven, copy the session-ejb-SNAPSHOT.jar file from the <session_home>/target directory to the following directory:
<jboss_home>\server\<your_server_name>\deploy
If JBoss is already started, it will automatically deploy and start the applications; otherwise, the applications will be deployed and started at the next startup.