www.tobuku.com

- 1 -

EJB PROGRAMMING WITH JBOSS March 2013 Level: √ By : Feri Djuandi Beginner Intermediate Expert

Platform : Eclipse Juno, JBoss AS 7.1.1.

EJB at a Glance Enterprise JavaBeans (EJB) technology is the server-side component architecture for Java

Platform, Enterprise Edition (Java EE). EJB technology enables rapid and simplified development

of distributed, transactional, secure and portable applications based on Java technology.1

The discussion of EJB is very much closely related to the multi-tier programming or distributed

programming. To a beginner, EJB can be simply explained using the 3-tier programming model –

something that we learn at school and still relevant until today. If you are familiar with the

model, then the picture below is quite self explanatory so it won’t be explained further in this

article. If you are new, then you are suggested to seek the related literature in the Internet

which can be easily found and free.

Session bean is a type of EJB object that most commonly used by the Java programmers when

dealing with enterprise Java applications (we will learn other type of object like Message-driven

Bean in another occasion). It performs business service operations and orchestrates transaction

and access control behavior. EJB container in the middle tier is a server application where the

session beans are hosted and running. It provides a run-time environment for enterprise beans

within the application server. The container handles all aspects of an enterprise bean's

operation within the application server and acts as an intermediary between the user-written

business logic within the bean and the rest of the application server environment. Some popular

EJB containers are WebSphere Application Server, JBoss Application Server, WebLogic Server

and Apache Geronimo.

From the client side point of view, the EJB model is suitable for both desktop applications (i.e.

window/GUI programs or console/command line programs) and web applications.

1 Source: http://www.oracle.com/technetwork/java/javaee/ejb/index.html

Network Desktop

Client Network Database

EJB Container

Session

Beans

Presentation

tier Application tier/

Business Logic

Data tier

www.tobuku.com

- 2 -

As mentioned earlier, EJB is an implementation of a distributed computing where the processes

are split between the client (regardless the client is a thin or thick model) and the server side. In

order for the client and the server to be able to communicate, there is a communication tunnel

between the two nodes so they can pass messages back and forth. That tunnel is established by

a pair of objects so called proxy and stub. A proxy resides in the client side, while a stub in the

server side. A stub has a unique identifier in a specified network which used as an address by the

corresponding proxy to create a link.

A stub may be referred by more that one proxy. When there are several clients access the

session bean concurrently at the same time, the EJB container will manage the transactions in a

Network

Client

EJB Container

Session

Beans Proxy

Stub

Client

Proxy

Client

Proxy

Network Web

Client

Network Database

EJB Container

Session

Beans

Web Container

JSP,

Servlet

www.tobuku.com

- 3 -

queue to ensure the transactions are processed reliably (atomicity, consistency, isolation,

durability).2

That is enough for the brief EJB introduction, now we start the main course.

Starting the JBoss Application Server Make sure JBoss Application Server (JBoss AS) has been installed on your computer. If JBoss AS

hasn’t been installed, please read the other article in this website which easily explains how to

obtain and set up JBoss. Now let us start the server when you are ready.

In this tutorial, we assume the JBoss AS is installed in the C:\jboss-as-7.1.1.Final directory. This

time we are going to start the application server.

1. Get into the bin sub-directory, locate the standalone.bat file and run it.

2. Open an Internet browser and try to access the URL: localhost:8080.

3. Click the Administration Console link to administer this application server. If it is the

first time the server is up, most probably you haven’t created any administrator ID. If so

you will be required to create it first before being able to open the console.

4. To create a user ID, enter the bin sub-directory again, locate the add-user.bat file and

run it.

Follow the step below to create an administrator ID:

Type of user : Management User (type “a”)

Username : asadmin

Password : 12345678

2 Source: http://en.wikipedia.org/wiki/ACID

www.tobuku.com

- 4 -

When the ID creation is completed, please go back to the Internet browser and click

again the “Administration Console” link. This time you will be prompted with a login box

to enter the user ID and password. Please proceed with the ID you’ve just created and

you will see the administration console right away.

5. Besides the JBoss administrator ID, we need another IDs that will be used by the

application client to connect to the JBoss AS. This time the appropriate ID is an

application user ID, instead of an administrator ID. Now let us repeat to run the add-

user.bat file.

Follow the step below to create a sample of an application user:

Type of user : Application User (type “b”)

Realm : <blank>

Username : user01

Password : 12345678

Roles : <blank, we will add it later>

www.tobuku.com

- 5 -

Upon the application user creation, be noted that JBoss will add some entries in the

following files:

a. ..\standalone\configuration\application-users.properties

b. ..\standalone\configuration\application-roles.properties

c. ..\domain\configuration\application-users.properties

d. ..\domain\configuration\application-roles.properties

Those files can be opened with any text editor program such as Ms Notepad. Now

please open the first file.

There is one entry corresponds to the user01. You may guess the encrypted characters

after the user name is the password.

Open the second file and see what inside it.

`

The application-roles.properties file contains a list of application users with their roles.

At this moment there may not any user with defined roles. Here we must associate our

application user example with at least one role so that the client application is able to

connect to JBoss using the user ID.

Please insert a new line in the bottom of the file and type “user01=PowerUser”. It

indicates that the user01 is granted the PowerUser role. It is a quite powerful user role,

but that is okay only for our example here. Save and close the files.

Please repeat the same steps for the files in the ..\domain\configuration directory.

We are done preparing the JBoss AS with the new IDs, now it is time for the exiting part:

creating the JBoss application!

www.tobuku.com

- 6 -

Creating the Session Beans This part explains the component programming which runs on the application server side.

1. Open Eclipse and create a new Enterprise Application Project, which is also referred to

as EAR project.

Name the project as MathBean Demo and ensure the selected target runtime is JBoss

AS. Click Finish to create the project files.

2. Create a new EJB Project.

Name the project as MathBean and ensure the selected target runtime is JBoss AS. Also

ensure to add the project to the MathBean Demo EAR.

Click Finish to create the project files.

www.tobuku.com

- 7 -

When it is done, you will realize that

Eclipse creates two EJB projects instead of

one!

There is a MathBean project, the one that

we expect to exist – and a

MathBeanClient project, the one which

appears surprisingly.

In fact, there is really nothing wrong with

this behavior. Notice that Eclipse

automatically creates the second project if

you recall that there must be a proxy-stub

pair in any distributed application. The

MathBean project relates to the stub part,

while the MathBeanClient project

corresponds to the proxy part.

MathBeanClient will consist of interfaces with all method declarations, but no business

logic inside them – the script is very less. On the other hand, MathBean comprises

www.tobuku.com

- 8 -

classes that implement the interfaces; therefore the programmers will spend most of

their time in working with these classes, writing the scripts to program the business

logic inside it.

3. Open the MathBeanClient project and create a new interface called ComputeBeanLocal.

Type the following code for the interface.

package demo.mathbean.server;

import javax.ejb.Local;

@Local

public interface ComputeBeanLocal {

double AddNumbers(double num1, double num2);

double SubtractNumbers(double num1, double num2);

double MultiplyNumbers(double num1, double num2);

double DivideNumbers(double num1, double num2);

}

Create the second interface called ComputeBeanRemote.

package demo.mathbean.server;

import javax.ejb.Remote;

@Remote

public interface ComputeBeanRemote {

double AddNumbers(double num1, double num2);

double SubtractNumbers(double num1, double num2);

double MultiplyNumbers(double num1, double num2);

double DivideNumbers(double num1, double num2);

}

www.tobuku.com

- 9 -

Both interfaces are very much alike except the local and remote key words. The reason

why we need to create two similar interfaces is to cope with two different calls: the

local call and remote call. Please see the following picture for the explanation.

Here both web container and the EJB

container are running in the same

JVM, therefore the calls made by the

JSP or servlet to the session beans are

local calls.

In this picure both client application and the session

bean are running in separate/different JVM, therefore

the calls made by client to the session beans are

remote calls.

For these two different calls, we must create respective interfaces whose methods may

or may not be the same.

4. Open the MathBeanClient project and create a new class called ComputeBean to

implement the previous interfaces.

Type the following code for the class.

package demo.mathbean.server;

import javax.ejb.Remote;

import javax.ejb.Stateless;

@Stateless

@Remote(ComputeBeanRemote.class)

public class ComputeBean implements ComputeBeanLocal,

ComputeBeanRemote{

public ComputeBean() {

}

Java

Desktop

Client

EJB Container

Session

Beans

JVM

Application Server

JVM

Remote

calls

EJB Container

Session

Beans

Web Container

JSP,

Servlet

JVM

Application Server

Local calls

www.tobuku.com

- 10 -

@Override

public double AddNumbers(double num1, double num2) {

return num1 + num2;

}

@Override

public double SubtractNumbers(double num1, double num2) {

return num1 - num2;

}

@Override

public double MultiplyNumbers(double num1, double num2) {

return num1 * num2;

}

@Override

public double DivideNumbers(double num1, double num2) {

return num1 / num2;

}

}

That’s it. We have done with the session beans.

www.tobuku.com

- 11 -

Packaging the Proxy and Stub The next step is to create the pair of proxy and stub. Later the stub will be deployed in the JBoss

AS, while the proxy will be embedded in a client application.

1. Open the MathBean Demo EAR created in the early steps, then right-click on the project

name and select Export ���� EAR file.

Export the project as MathBeanDemo.ear. That is the stub component.

If the file is opened using a decompression program such as WinZip, then we will see

two JAR files: MathBean.jar and MathBeanClient.jar. Be noted that MathBean.jar is the

session bean where the business logic resides.

www.tobuku.com

- 12 -

2. Open the MathBeanClient project in the early steps, then right-click on the project

name and select Export. From the Export dialog window, select Java ���� JAR file.

Name JAR file as MathBeanClient.jar. That is the proxy component.

www.tobuku.com

- 13 -

If the file is opened using a decompression program such as WinZip, then we will see

two class files: ComputeBeanLocal.class and ComputeBeanRemote.class. Be noted that

these classes are merely interfaces – no business logic at all.

Deploying the Stub in JBoss AS The session bean inside the generated EAR file should be put on the JBoss AS.

1. Open the JBoss AS administration console and login using an administrator ID created

earlier.

www.tobuku.com

- 14 -

Open the Manage Deployments menu. At this time there may not be any items in the

list. Click the Add Content button to upload to EAR file.

Locate the MathBeanDemo.ear file and click Next.

Click Save to upload.

2. Now the MathBeanDemo should appear in the item list. Please ensure the item is

enabled. If not, then press the Enable button.

That’s all. We are done deploying the stub in the JBoss AS.

www.tobuku.com

- 15 -

Creating a Client Application

The last part is to create a client application that tries to call the session bean remotely.

1. Open Eclipse and create a new ordinary Java Project.

Name the project as MathBean ClientApp.

2. Click the Libraries tab to associate the JAR files.

Click the Add External JARs button to add two JAR files:

a. Jboss-client.jar – add this file from the JBoss installation directory

under ..bin\client.

b. MathBeanClient.jar – add this generated proxy file from the earlier step.

Click Finish to generate the project files.

www.tobuku.com

- 16 -

3. Create a new class, name it as MainClass and include the main() method.

Click Finish to save the class.

www.tobuku.com

- 17 -

4. Open the class just created and type the following code.

package demo.mathbean.client;

import java.util.Properties;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import demo.mathbean.server.ComputeBeanRemote;

public class MainClass {

public static void main(String[] args) {

try {

Properties properties = new Properties();

properties.put(Context.INITIAL_CONTEXT_FACTORY,

"org.jboss.naming.remote.client.InitialContextFactory");

properties.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");

properties.put(Context.PROVIDER_URL, "remote://localhost:4447");

properties.put(Context.SECURITY_PRINCIPAL, "user01");

properties.put(Context.SECURITY_CREDENTIALS, "12345678");

properties.put("jboss.naming.client.ejb.context", true);

Context ctx = new InitialContext(properties);

final String appName = "MathBeanDemo"; //The application name in the JBoss AS

final String moduleName = "MathBean"; //The name of the session bean (the JAR file)

final String distinctName = "";

final String beanName = "ComputeBean"; //The class name of the session bean

final String viewClassName = ComputeBeanRemote.class.getName();

//The interface name (either local or remote)

String lookupObj = "ejb:" + appName + "/" + moduleName + "/" + distinctName + "/" +

beanName + "!" + viewClassName;

ComputeBeanRemote bean = (ComputeBeanRemote)ctx.lookup(lookupObj);

System.out.println("Add: " + bean.AddNumbers(100, 20));

www.tobuku.com

- 18 -

System.out.println("Divide: " + bean.DivideNumbers(100, 20));

System.out.println("Multiply: " + bean.MultiplyNumbers(100, 20));

System.out.println("Subtract: " + bean.SubtractNumbers(100, 20));

}

catch (NamingException e) {

e.printStackTrace();

}

}

}

One of the important code lays in the following line:

...

ComputeBeanRemote bean = (ComputeBeanRemote)ctx.lookup(lookupObj);

...

This line tells the program to search a session bean or a stub which identified with addressed by the lookupObj variable. When it is found,

the a link will be established using a proxy which represented by the bean variable. Be noted that the bean variable is an instance of the

ComputeBeanRemote interface - not the actual class itself. But amazingly the method calls of the object return the values just like what

we expect as if we call the class (notice that an interface does not have any business logic). So we’re quite confident that these proxy-

stub things really work.

The lookupObj variable is an instance of a Properties object type. It represents the address of the application server that the proxy

wishes to locate.

...

properties.put(Context.INITIAL_CONTEXT_FACTORY,

"org.jboss.naming.remote.client.InitialContextFactory");

properties.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");

properties.put(Context.PROVIDER_URL, "remote://localhost:4447");

properties.put(Context.SECURITY_PRINCIPAL, "user01");

properties.put(Context.SECURITY_CREDENTIALS, "12345678");

properties.put("jboss.naming.client.ejb.context", true);

...

www.tobuku.com

- 19 -

Some of the properties above like INITIAL_CONTEXT_FACTORY and URL_PKG_PREFIXES

should be assigned with values that already given by the vendor of the allocation server,

so that’s not arguable – just receive it. The other application servers will have different

values, so you need to read the related documentation carefully. The PROVIDER_URL

property represents the address of the server. If the server is not a local computer, it

can be set as an IP address or a server name

Both SECURITY_PRINCIPAL and SECURITY_CREDENTIALS properties are the application

user ID and password that we discussed earlier.

5. Save and run the code.

If the program works well, you should see the output of the program as shown in the

picture above.

We have learned how to create a very simple distributed application using JBoss. There are a lot

of fantastic things that can be done by JBoss. As a hungry learner, you are highly recommended

to seek another literature that written by professional authors and experienced practitioners

where you can obtain various techniques and knowledge.

References:

� Kodali, Raghu R. and Jonathan Wetherbee. “Beginning EJB3 Application Development”.

Apress. 2006

� https://docs.jboss.org/author/display/AS71/EJB+invocations+from+a+remote+client+usi

ng+JNDI

� http://www.oracle.com/technetwork/java/javaee/ejb/index.html