Home > Articles > Programming > Java

  • Print
  • + Share This
Like this article? We recommend

Building a Simple "Hello, World" EJB

Borrowing from the C world, the EJB application we'll build is one that returns the string "Hello, world". This example guides you through the process of making an EJB. More complex EJBs can be developed by following the same process and adding more methods to the Remote interface.

First start Borland AppServer and then JBuilder. When you become more proficient in Java and JBuilder, you can eventually develop and test your EJBs totally within the JBuilder environment. In this section, we'll develop the EJB and deploy it to the Borland AppServer. Then we'll make a Delphi client that will connect to the EJB. This is a more realistic scenario for real-world development and deployment.

To build the "Hello, world" EJB, follow these steps:

  1. Close down all projects within JBuilder. Then choose File, New Project. Give this project the name HelloWorld. This will also be the name of the project file when JBuilder saves it to disk.

  2. Next we need to add an EJB group. Choose File, New, Enterprise and select the Empty EJB Group icon. When prompted for a name, enter HelloGroup. Notice that an edit control specifies the name of the jar file into which this application will be built. A jar file is similar to a zip file; you archive all the Java bytecode files into a jar file so that you only have one file to deploy. In this case, rename the jar file to HelloWorld.jar.

  3. Next add a new EJB by selecting File, New, Enterprise and selecting Enterprise Java Bean. When prompted for a name, enter HelloBean. JBuilder 5 will automatically create the bean and all the required interfaces.

  4. Select the HelloBean.java file in the project window and click the Source tab. Make sure that your source code resembles Listing 1.

    Listing 1—The JavaBean Source

    package helloworld;
    import java.rmi.*;
    import javax.ejb.*;
    import java.lang.String;
    public class HelloBean implements SessionBean
    {
      private SessionContext sessionContext;
      public void ejbCreate()
      {
      }
      public void ejbRemove() throws RemoteException
      {
      }
      public void ejbActivate() throws RemoteException
      {
      }
      public void ejbPassivate() throws RemoteException
      {
      }
      public void setSessionContext(SessionContext sessionContext) throws
      RemoteException
      {
       this.sessionContext = sessionContext;
      }
      public String sayHello() {
       return "Hello, world";
      }
    }
  5. You need to enter the last method in the code block (sayHello()). This method returns a string, so it must include the java.lang.String package as shown near the top of the file.

  6. Now we need to expose the sayHello() method through the Remote interface. To do that, select the Bean tab at the bottom of the code window. Then select the Methods tab at the bottom of the Bean tab window. You'll see the sayHello() method listed with an unchecked check box next to it. Check the box to expose the method through the Remote interface. To verify this, double-click the Hello.java file in the project window. This brings up the source for the Remote interface. Notice that sayHello() is there now.

  7. Save your work and build the project. You should have no errors.

Building a Client Test Application in JBuilder

JBuilder lets you build a client-side Java application to test your EJB. Follow these steps:

  1. Choose File, New, Enterprise and select EJB Test Client. Name this HelloTestClient1.java.

  2. JBuilder will automatically create the file. At the bottom of the file, you'll see a main program. Make yours resemble Listing 2 by adding the create() and sayHello() methods to the main program.

    Listing 2—EJB Java Test Client Application

    public static void main(String[] args) {
      HelloTestClient1 client = new HelloTestClient1();
      client.create();  //add these two lines
      client.sayHello();
      // Use the client object to call one of the Home interface wrappers
      // above, to create a Remote interface reference to the bean.
      // If the return value is of the Remote interface type, you can use
      // it to access the remote interface methods. You can also just use
      // the client object to call the Remote interface wrappers.
    }

Building the Client and Testing the EJB

Now build the test client. Follow these steps:

  1. Run the EJB by right-clicking the HelloGroup entity in the project window and choosing Run from the pop-up menu. Soon you should see messages in the JBuilder message pane indicating that the EJB is running. This might take 20–30 seconds, depending on the speed and memory of your machine. Remember, Java is a resource hog.

  2. Right-click the client application and choose Run. You'll see it start up and eventually print Hello, world to the message window. This means that our EJB works correctly.

  3. You can stop the EJB group by clicking the red Stop button at the bottom of the message window.

Deploying the EJB to AppServer

To deploy the EJB to AppServer, follow these steps:

  1. Select Tools, EJB Deployment. Follow the wizard, and it will deploy the EJB.

  2. Once the EJB is deployed, AppServer will automatically start it. Click the Next button until you reach step 4.

  3. In step 4 of the wizard, you must select an EJB container. Make sure that Borland AppServer is running. Then click the Add EJB Container button, and you'll see the AppServer container. Select it and click OK; then continue with the wizard until it completes.

Generating the SIDL File

Borland has developed a proprietary technique to remap EJBs to an AppServer interface called Simplified IDL (SIDL). This remapping makes sure that older CORBA applications can call EJBs by using the CORBA 2.1 standard (or higher). The SIDL compiler tool that ships with AppServer can take a Remote interface and generate conventional IDL files.

Borland provides a free plug-in for JBuilder that facilitates converting the EJB interfaces to IDL with the SIDL compiler. The plug-in is a Java jar file called otSIDL.jar. Copy it to the directory where you installed JBuilder. You'll have to restart JBuilder to activate the tool.

When the JBuilder IDE comes up, choose Tools, IDE Options, and you'll see a dialog box with a tab for SIDL. Select the SIDL tab and specify an output directory. In this case, enter c:\MyProjects\HelloWorld (or wherever you stored the HelloWorld project). This tool adds a pop-up menu to the EJB Remote interface.

Right-click the HelloHome.java file in the project list. You'll see a menu item called Generate Simplified IDL. Choose that, and it will run the SIDL compiler. The output will be in the classes directory for the project.

Developing the EJB Client in Delphi

Now that we have a complete EJB, we can take the IDL file generated by the SIDL compiler and create a Delphi CORBA client to talk to the EJB. If you look under the EJB project's classes directory, you'll see a file called HelloHome.idl. You'll need this and a copy of the sidl.idl file found in the following directory:

Delphi6\Demos\Corba\Idl2pas\EJB\EuroConverter

Put those two files in a new directory. Then follow these steps:

  1. Start Delphi and choose File, New, Other, CORBA, CORBA Client Application.

  2. Add the HelloHome.idl file to the list of files that will be processed. You don't need to add the sidl.idl file because it's included automatically in HelloHome.idl via the include.

  3. The wizard will create a new CORBA client. Save the project and call it HelloClient. Many file windows will be displayed after the wizard runs. Other than the Unit1.pas file, the only two that need to be displayed are HelloHome_HelloWorld_i.pas and HelloHome_HelloWorld_c.pas. All the rest can be closed.

  4. On the main form, drop a button and label control. Make your application resemble Figure 1.

    Figure 1Figure 1 The EJB Delphi client.

  5. In the form's OnCreate() method, enter initCorba.

  6. Modify the initCorba() method to resemble the code block shown in Listing 3. You'll have to add two variables to the class definition. One is for the Home interface; the other is for the Remote interface. The Home interface is a factory that creates Remote interfaces. Once you have an instance of the Remote interface, you can call the methods on the EJB. So the initCorba() method will contain the code that binds to the Home interface and generates a Remote interface object.

  7. Add a button OnClick event and make it resemble the button OnClick code block shown in Listing 3.

  8. Build the client application.

    Listing 3—The EJB ClientMain Application File

    unit ClientMain;
    
    interface
    
    uses
     Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
     Corba, HelloHome_c, HelloHome_helloworld_c, HelloHome_helloworld_i,
     HelloHome_i, HelloHome_sidl_javax_ejb_c, HelloHome_sidl_javax_ejb_i,
     HelloHome_sidl_java_lang_c, HelloHome_sidl_java_lang_i,
     HelloHome_sidl_java_math_c, HelloHome_sidl_java_math_i,
     HelloHome_sidl_java_sql_c, HelloHome_sidl_java_sql_i,
     HelloHome_sidl_java_util_c, HelloHome_sidl_java_util_i,
     StdCtrls;
    
    type
     TForm1 = class(TForm)
      Button1: TButton;
      Label1: TLabel;
      procedure FormCreate(Sender: TObject);
      procedure Button1Click(Sender: TObject);
     private
     { private declarations }
     protected
      myHome : HelloHome;
      myRemote : Hello;
      procedure InitCorba;
     { protected declarations }
     public
     { public declarations }
     end;
    
    var
     Form1: TForm1;
    
    implementation
    
    {$R *.DFM}
    
    procedure TForm1.InitCorba;
    begin
      CorbaInitialize;
     
      myHome := THelloHomeHelper.Bind;
      myRemote := myHome._create;
    end;
    
    procedure TForm1.FormCreate(Sender: TObject);
    begin
      initCorba;
    end;
    
    procedure TForm1.Button1Click(Sender: TObject);
    begin
      Label1.Caption := myRemote.sayHello;
    end;
    
    end.

Running the Application

To run the application, follow these steps:

  1. Start the OSAgent.

  2. Make sure that Borland AppServer has started.

  3. Start the HelloClient. Click the button, and you should see the label text change to Hello, world.

More complex EJBs can be developed by following a similar development process. In Java, you just add more method interfaces to increase the capabilities of the EJB. The client-side process will essentially remain the same as this example. Delphi CORBA clients will be built by gathering the SIDL-produced IDL files and processing them through the Delphi CORBA IDE wizard.

  • + Share This
  • 🔖 Save To Your Account