Example of EJB3 (Session Bean) using Eclipse Europa and JBoss

After the frustration of EJB 2, EJB 3 is growing in the community every day.

Different from EJB 2, EJB3 is simpler and much productive. However you have to pay attention before work with EJB3.

First of all, you have to make sure that your Production environment has Java 5 version, as well as your Application Server is JEE 5-compliance. Many servers do not have this configuration yet. (I myself work in a project that uses J2EE 1.4).

Also, EJB 3 does not need to be used in ALL applications. You have to think if in your project EJB is really necessary. In general, EJB are used when you need of distributed components.

JBoss is one of the most popular open-source Application Server and its version 4.2 supports JEE 5. Glassfish from Sun is also another good choice for free application server.

In this topic I am going to show you a simple example of how to create a Session Bean using Eclipse Europa and JBoss Application Server. If you do not have the JBoss AS installed, you can check this topic to install it.

After install Java 5 or 6, JBoss AS and Eclipse Europa, it is time to create the application itself. Let’s open the Eclipse and prepare our developer skill

Configuration JBoss within Eclipse Europa

Inside the Eclipse Europa, open the Servers view (Window -> Show View -> Servers). Right mouse click on Servers view and choose option New -> Server.

Choose the JBoss 4.2 and its path. After that the JBoss server should appear on the Servers view.

Creating the Enterprise Application Project

On Eclipse IDE (Using the Java EE perspective), right mouse click on Package Explorer and go to New -> Enterprise Application Project.

Choose the Project Name (e.g: TestApplication), Target Runtime (JBoss 4.2) and click on Next button.

On the next screen keep the EAR checked and click on Next. On the third screen, click on New Module button to select the modules you want to install. Let’s work on with two modules (EJB and Web). Choose these modules and click OK. Also, on third screen mark the option Generate Deployment Descriptor.

After that, the Enterprise Application Project will be created, as well as the EJB and Web modules. All of them can be reached in the Package Explorer.

Creating our first EJB component (Stateless Session Bean)

In Eclipse Europa, there is not an option to create a EJB component itself. You have to do it manually. However in the new EJB version, you can use Annotations rather than a Deployment Descriptor (XML) to map your components. As the annotation is much easier than XML, you will not loose productive in the component development.

Remember: In EJB 3 you need only two files: an Interface (local or remote) and its implementation. By default, the interface receives the name of the component and the implementation receives the name of the component plus Bean.

The first think to do is to create our Interface. In your example, we are going to use a simple Session Bean which has one method (public void getMessage). So creates this interface inside the EJB project. Right mouse click on TestApplicationEJB -> New -> Interface.

Also, put the method public String getMessage(); into this interface.

package lesson.stateless;
public interface HelloWorld {
	public String getMessage();
}

The next step is to create the class that implements this interface. The pattern is the class has the same name than the interface plus Bean.

To create a click, right mouse click on TestApplicationEJB -> New -> Class. Insert the class name and choose the Interface.

Note: As the interface calls HelloWorld, than our class calls: HelloWorldBean.

Now it is time to implement the HelloWorldBean.java class. It is a simple class which contains only one method. Look at its implementation below:

package lesson.stateless;

import javax.ejb.Remote;
import javax.ejb.Stateless;

@Stateless
@Remote(HelloWorld.class)
public class HelloWorldBean implements HelloWorld {
    public String getMessage() {
        return "Hello EJB World";
    }
}

Pay attention on line 6 and 7. The @Stateless annotation tells to the AS which the component is a Stateless Session Bean. Also, the @Remote annotation tells to the AS which interface is the remote for this implementation.

Done! Our EJB module is done to be deployed. If you are coming from EJB 2, you can see how the EJB 3 is much easier and productive

Using the Web Module as EJB Client.

It is common you have in the same EAR a EJB Module and a Web Module. In this case, the Web module works as a EJB Client, in other words, the We Module is going to be the FRONT-END as long as the EJB Module is going to be the BACK-END.

In our example we will use a simple Web Module. A single JSP file that call a servlet. The servlet makes connection with the EJB Module and print out in the console the message from EJB.

First of all, let’s create the JSP file. Expand the TestApplicationWeb and right click on WebContent -> New -> JSP. Create a jsp with the name index. Inside the JSP, put a call to the servlet. Let’s call our servlet as TestServlet. The JSP content could be anything like this:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<body>
    <h1>Web Module used as EJB Client</h1>
    <a href="TestServlet">Click here to call the EJB component</a>
</body>
</html>

Now it is time to create the Servlet component. Right mouse click on TestApplicationWeb -> New -> Servlet. Put the name TestServlet and choose a package (if you want).

Before implement this method, we need to create a binding between the Web Module and the EJB Module. To do that right mouse click on TestApplicationWeb -> Properties.

Go to J2EE Module Dependencies and mark the option TestApplicationEJB.jar. Thus your Web module will see the EJB interfaces, but remember, you cannot call it directly.

Now we are able to implement the servlet. We are going to use only the method doGet (fell free to get rid of the doPost method). Inside the doGet method, we are going to call the EJB component and show its return message.

package lesson.servlets;

import java.io.IOException;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import lesson.stateless.HelloWorld;

public class TestServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
    static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            InitialContext ctx = new InitialContext();
            HelloWorld hello = (HelloWorld) ctx.lookup("TestApplication/HelloWorldBean/remote");
            System.out.println(hello.getMessage());
        } catch (NamingException e) {
            e.printStackTrace();
        }
    }
}

Check out the lines 18 to 20.

• In the line 18, we start an InitialContext object. As we are working inside the same EAR than the EJB, we cannot pass none parameter for its constructor. In the next example (Creating a Java stand-alone client), you will see that a Properties file is required.
• In the line 19 we call the remote object HelloWorld. Pay attention on its JNDI name. The JBoss pattern is: First the EAR name / The EJB Implementation Component / remove or local. The ctx.lookup method looks for the remote object inside the EJB module and returns its instance.
• In the line 20 we prints out the return of the getMessage() method.

Note: The annotation @EJB does not work properly in JBoss server. If anyone had success using this annotation, please let me know :).

Now you can run this application. Right mouse click on TestApplicationWeb -> Run As -> Run on Server. The first time you try to run the application, a screen regarding server configuration will come up. Select the JBoss 4.2 server (you previosly configurated) and mark the option Always use this sever when running this project. Click OK and the server will starts.

Inside the Eclipse you will see the web page. Click on the link and look at the Eclipse Console. A message from EJB should appears for you.

Creating a Java Stand-Alone Client

You should use EJB when you need of distributed components. Besides use distributed components in the server (through clustering, SOA, and so on), you can create a communication between a Stand-Alone application.

A Stand-Alone application calls the EJB in a similar way then Web Modules, however it has some particularities.

1. You have to import some JBoss libraries to the stand-alone application
2. You have to create a Properties file and use it in the InitialContext object
3. The Stand-Alone application must “know” the remote components interfaces.

Create a Java Project, File -> New -> Project -> Java Project.

Import the following two files to this project

jbossall-client.jar
jboss-ejb3-client.jar

You can find these files inside $JBOSS_HOME/client directory. To add them to the Project classpath, right click on Java Project -> Propeties. Go to Java Build Path -> Libraries -> Add External JARs.

Also, inside the Properties screen, click on Projects tab and then Add button. Select the EJB module. This way your client application will see the remote ejb object.

Create a properties file (called jndi.properties) in the root of the Client project. The content of the file is below:

java.naming.factory.initial     = org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs     = org.jboss.naming:org.jnp.interfaces
java.naming.provider.url        = localhost:1099

Now create a simple Java class containing the void main (String args[]) method.

Implement this method, using the Properties file previously created as argument to InitialContext object.

package lesson.client;

import java.io.FileInputStream;
import java.util.Properties;

import javax.naming.InitialContext;

import lesson.stateless.HelloWorld;

public class TestClient {

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.load(new FileInputStream("jndi.properties"));
        InitialContext ctx = new InitialContext(props);
        HelloWorld hello = (HelloWorld) ctx.lookup("TestApplication/HelloWorldBean/remote");
        System.out.println(hello.getMessage());
    }
}

Before run the client application, make sure the Application Server is running. If so, runs your Main class and see the output in the Eclipse Console view.

This topic ends here. I hope this topic can help the people who wants to work with EJB in Eclipse Europa. The next topic is the same example, but using Netbeans 6.1 and Glassfish. I hope you enjoy it.

---

Possibly related posts: (automatically generated)

• Adding Glassfish support on Eclipse Europa