MWT Lab Manual1

B.E. 4/4 – I semester

BIT 432 MIDDLEWARE TECHNLOGIES LABORATORY

List of Experiments Prescribed by Osmania University

1. Creation of a Distributed Name Server, using RMI

2. Creation of a Java Bean application for displaying graphical shapes

3. Developing an EJB for Student Information System.

4. Developing an EJB for Library Information System.

5. Creation of an ActiveX control for Time Table.

6. Developing a component for converting currency values using COM/.NET.

7. Developing a component for browsing the CD catalog using COM/.NET

8. Developing a component for retrieving information from message box using

DCOM/.NET.

9. Developing a Middleware component for retrieving Stock Market Exchange

information using CORBA

10. Developing a Middleware component for retrieving Bank Balance using CORBA.

1

MIDDLEWARE TECHNOLOOGIES LAB

CONTENTS

S No Name Of the Experiment Page No

1 Creation of a Distributed Name Server, Using RMI. 4

2 Creation of a Java Bean application for displaying graphical shapes 10

3 Developing an EJB for Student Information System. 15

4 Developing an EJB for Library Information System. 20

5 Creation of an ActiveX control for Time Table. 25

6 Developing a component for converting currency values using COM/.NET. 28

7 Developing a component for browsing the CD catalog using COM/.NET. 30

8Developing a component for retrieving information from message box using

DCOM/.NET.33

9Developing a Middleware component for retrieving Stock Market Exchange

information using CORBA35

10Developing a Middleware component for retrieving Bank Balance using

CORBA.40

2

1. Creation of a Distributed Name Server, Using RMI.

AIM: Creation of a Distributed Name Server, Using RMI

Apparatus: J2SDK 1.5 Software

rmic tool

java compiler, java tool, notepad/Edit plus

Flow:

Remote Method Invocation (RMI)

In Java distributed object model, a remote object is one whose methods can be

invoked from another Java Virtual Machine.

Allows object-to-object communication between Java Virtual Machines.

RMI is the action of invoking a method of a remote interface on a remote object.

A remote object is always accessed via its remote interface.

In RMI the terms ‘server’ and ‘client’ refer to objects, but not physical machines.

3

Client invoking method on the remote object

Stub

Remote Reference Layer

TCP

IP

Hardware Interfaces

Remote Object

Skeleton

Remote Reference Layer

TCP

IP

Hardware Interfaces

Physical Layer

The stubs/skeletons layer intercepts method calls made by the client to the interface

reference and redirects these calls to a remote object. Stubs are specific to the

client side, whereas, skeletons are found on the server side.

The remote reference layer handles the details relating to interpreting and managing

references made by clients on the remote objects. It connects clients to remote

objects that are running and exported to a server by a one-to-one connection link.

The transport layer is based on TCP/IP connections between machines in a

network.

Procedure:

The basic steps involved in writing client-server applications using RMI :

1. Defining a remote interface

2. Implementing the remote interface

3. Writing the client that uses the remote objects

4. Connecting stubs and skeletons

5. Starting the registry and registering the object

6. Running the server and the client.

Defining the Remote interface:

o The remote interface must be declared public

o The remote interface must extend java.rmi.Remote interface

o Each method must throw a java.rmi.RemoteException

o If the remote methods have any remote objects as parameters or return

types, they must be interface types not the implementation classes.

o java.rmi.Remote interface has no methods

4

Programming:

// Program to create a remote interface

import java.rmi.*;

public interface MyRemoteInterface extends java.rmi.Remote

{

public String displayDate() throws RemoteException;

}

Implementing the Remote Interface:

The implementation class provides the implementation for methods defined in the

remote interface.

The generic java.rmi.server.RemoteObject is an abstract class and describes the

behavior for remote objects.

The abstract class java.rmi.server.RemoteServer describes the behavior

associated with the server implementation and provides the basic semantics to

support remote references.

java.rmi.server.RemoteServer has two subclasses :

java.rmi.server.UnicastRemoteObject

java.rmi.activation.Activatable

// Program for implementation of the Rremote Interface

import java.io.*;

import java.util.Date;

import java.rmi.server.*;

import java.rmi.*;

public class MyImplementor extends UnicastRemoteObject implements

MyRemoteInterface

{

public MyImplementor() throws RemoteException

5

{

super();

}

public String displayDate() throws RemoteException

{

System.out.println(“Hello! The date is “ + new Date());

}

}

A remote class can define any methods, but only methods in th remote interface

can be invoked remotely.

The Client application

// Program to generate the client

import java.rmi.*;

import java.io.*;

public class MyRemoteClient

{

public static void main(String[] args)

{

/*if (System.getSecurityManager() == null)

{

System.setSecurityManager(new SecurityManager());

}*/

BufferedReader br = new BufferedReader(new

InputStreamReader(System.in));

try

{

System.out.println("Enter IP Address: ");

String ipaddr = br.readLine();

6

/*System.out.println("Enter value2 : ");

int value2 = Integer.parseInt(br.readLine());

System.out.println("The values are : " + value1 + " " + value2);

MyRemoteServer mobj = new MyRemoteServer();

Naming.rebind("/MyRemoteServer",mobj);*/

MyRemoteInterface mobj = (MyRemoteInterface)

Naming.lookup("rmi://localhost:1099/RemoteService");

String msg1 = mobj.displayDate();

String msg2 = mobj.displayHostname(ipaddr);

System.out.println(msg1);

System.out.println(msg2);

}

catch (RemoteException re)

{

System.err.println("Client Exception : " + re);

}

catch (IOException ioe)

{

System.err.println("The exception is : " + ioe);

}

catch (Exception e)

{

e.printStackTrace();

}

}

}

7

The Server application

// Program to implement the remote interface

import java.rmi.*;

import java.rmi.server.*;

import java.util.*;

import java.rmi.Naming;

public class MyRemoteServer

{

public MyRemoteServer()

{

try

{

MyRemoteInterface c = new MyRemoteImplementer();

Naming.rebind("rmi://localhost:1099/RemoteService", c);

}

catch (Exception e)

{

System.out.println("Trouble: " + e);

}

}

public static void main(String args[])

{

new MyRemoteServer();

}

}

javac *.java – to compile all the java files

rmic Myimplementor – to generate stubs and skeletons

start rmiregistry

java MyRemoteServer

java MyRemoteClient

8

Observations:

The actual DNS application involves the following modifications to the above

mentioned sample program:

1) The services to be provided are to be declared in the remote interface declared by the

user. The services could be: getIPAddress, getDomainName, returnIPAddress,

returnDomainName

2) The above-mentioned services are to be implemented in the implementer class. As

part of implementation the database is to be accessed to retrieve the DNS information,

for which JDBC is to be made use of.

3) The client program would have code to get connected to the server and make the

remote calls to the server for the required services.

4) The server program would create an instance of the remote implementer and would

provide the services requested services to the client.

Steps to be followed for execution:

1) All the programs are to be compiled using the command javac.

2) The stub is to be generated by compiling the implementer class using the

command rmic <implementerclassname>.

3) The RMI registry service is then started using the command :

start rmiregistry.

4) Then the server is registered with the RMI registry by running the server program

using the command java.

5) The client is also then run using the command java.

Result: If the input to the application is an IP Address, then, it should return back the

Domain Name and vice versa.

9

2. Creation Of A Java Bean Application For Displaying Graphical

Shapes

AIM: Creation of a Java Bean Application for Displaying Graphical Shapes

Apparatus: J2SDK 1.5 Software

AWT tool


Flow:

Java Bean

A Java Bean is an independent and reusable software component that can be

manipulated visually in a builder tool.

A bean is represented by an interface that is seen by the users. The environment

must connect to the interface, if it wants to interact with this bean. Beans consist of

three general-purpose interfaces: events, properties and methods.

Bean events are the mechanism for sending asynchronous messages between beans,

and, between beans and containers.

The Java Beans architecture communicates primarily using event listener interfaces

that extend EventListener

The properties of a bean can be changed .at runtime through their get and set

methods.

The JavaBean introspection process exposes the properties, methods and events of

a bean and also any global information about a bean. This is done through the

BeanInfo interface, provided by the Java Beans API.

Programming:

The following is a sample application that is used to display colors using a bean:

// Program to test beans

import java.beans.*;

public class MyColorsBeanInfo extends SimpleBeanInfo

{

public PropertyDescriptor[] getPropertyDescriptors()

{

try

10

{

PropertyDescriptor rectangular = new

PropertyDescriptor("rectangular",MyColors.class);

PropertyDescriptor pd[] = {rectangular};

return pd;

}

catch (Exception e)

{}

return null;

}

}

// Program to test Java Beans

import java.awt.*;

import java.awt.event.*;

import java.io.Serializable;

public class MyColors extends Canvas implements Serializable

{

transient private Color color;

private boolean rectangular;

public MyColors()

{

addMouseListener(new MouseAdapter()

{

public void mousePressed(MouseEvent me)

{

change();

}

} );

rectangular = false;

11

setSize(200,100);

change();

}

public boolean getRectangular()

{

return rectangular;

}

public void setRectangular(boolean flag)

{

this.rectangular = flag;

repaint();

}

public void change()

{

color = randomColor();

repaint();

}

private Color randomColor()

{

int r = (int) (255 * Math.random() );

int g = (int) (255 * Math.random() );

int b = (int) (255 * Math.random() );

return new Color(r,g,b);

}

public void paint(Graphics g)

{

Dimension d = getSize();

int h = d.height;

int w = d.width;

12

g.setColor(color);

if (rectangular)

{

g.fillRect(0,0,w-1,h-1);

}

else

{

g.fillOval(0,0,w-1,h-1);

}

}

}

// Program to test beans

import java.awt.*;

import java.beans.*;

public class IntrospectorDemo

{

public static void main(String[] args)

{

try

{

Class c = Class.forName("MyColors");

BeanInfo beanInfo = Introspector.getBeanInfo(c);

System.out.println("properties:");

PropertyDescriptor propertyDescriptor[] =

beanInfo.getPropertyDescriptors();

for( int i=0; i < propertyDescriptor.length; i++)

{

System.out.println("\t" + propertyDescriptor[i].getName());

}

System.out.println("events:");

13

EventSetDescriptor eventsetDescriptor[] =

beanInfo.getEventSetDescriptors();

for(int i =0; i < eventsetDescriptor.length; i++)

{

System.out.println("\t" + eventsetDescriptor[i].getName());

}

}

catch (Exception e)

{

System.out.println("Exception caught. " + e);

}

}

}

Procedure:

For displaying the various graphical shapes, the classes from the AWT package can

be used.

The code relevant to this can be put as part of an applet and can be executed in a

Java enabled web browser.

The application can also be implemented using any of the builder tools like the

Eclipse or the NetBeans.

The expected output from the application to be done is that it should display

various graphical shapes in the browser or in the tool used.

Steps for execution:

1) Compile all the files

2) Execute the introspector from the prompt or run the applet in a Java enabled web

browser.

Observations & Result: The expected output from the application to be done is that it

should display various graphical shapes in the browser or in the tool used.

14

3. Developing an EJB for Student Information System

AIM: Developing an EJB for Student Information System

Apparatus: J2SDK 1.5 Software, Myeclipse workbench Installer

Weblogic application server 8.1, NetBeans IDE


Flow:

Enterprise Java Beans (EJB)

EJB components are designed to encapsulate business logic, and to protect the

application developer from having to worry about many system-level issues like

transactions, security, etc.

An EJB is just a collection of Java classes and XML file, bundled into a single unit.

An EJB runs in an EJB container. The EJB container runs within an application

server and takes responsibility for system-level issues.

EJB specification is intended to provide enterprise-level services.

EJBs provide persistence services.

There are three types of EJBs. Session Beans – stateful and stateless, message

driven beans and, Entity beans.

The Session and Entity beans must have two interfaces: Home and Remote

Interface.

The Remote and Home interfaces can be used to access the EJB either remotely or

locally within the same container.Programming:The following is a sample

application using EJB:// Program to declare the Remote interfaceimport

java.rmi.RemoteException;import javax.ejb.EJBObject;public interface Hello

extends EJBObject{ public String sayHello(String str)throws

RemoteException;}// Program to declare the Home interfaceimport

java.rmi.RemoteException;import javax.ejb.EJBHome;import

javax.ejb.CreateException;public interface HelloHome extends EJBHome{ public

Hello create() throws RemoteException,CreateException;}// Program to implement

the beanimport java.rmi.RemoteException;import javax.ejb.SessionBean;import

15

javax.ejb.SessionContext;import javax.ejb.CreateException;public class HelloBean

implements SessionBean{ private SessionContext ctx; public void

ejbActivate() { System.out.println("Hello Bean:Activated"); }

public void ejbPassivate() { System.out.println("Hello

Bean:Passivated"); } public void setSessionContext(SessionContext sc)

{ ctx=sc; System.out.println("Hello Bean:Session Context");

} public void ejbRemove() { System.out.println("Hello

Bean:Removed");} public void ejbCreate() throws CreateException {

System.out.println("Hello Bean:Created"); } public String

sayHello(String str)throws RemoteException {

System.out.println("Hello Bean:Say"); return "Hello:"+str; }}//

Program to develop the client applicationimport java.rmi.*;import java.util.*;import

javax.ejb.*;import javax.rmi.*;import javax.naming.*;public class HelloClient{

public static void main(String args[]) { Properties p=new

Properties();

p.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextF

actory"); p.put(Context.PROVIDER_URL,"t3://localhost:7001");

try { InitialContext ctx=new InitialContext(p);

Object obj=ctx.lookup("HelloBean"); Class cls=HelloHome.class;

Object o=PortableRemoteObject.narrow(obj,cls); HelloHome

h=(HelloHome)o; Hello r=h.create(); String

result=r.sayHello(args[0]); System.out.println(result);

r.remove(); } catch (Exception e)

{ e.printStackTrace(); }

}}Procedure:For the execution of the above application the following steps are to

be carried out:

Compile all the java programs.

For generating the component , open the Weblogic Builder tool

16

Open the directory where all the .class files are stored. The builder tool

will automatically recognize the bean class and would prompt for creation

of the deployment descriptor.

Click on save and close. After this the tool will create a folder META-INF

with the files ejb-jar.xml and weblogic-ejb-jar.xml.

Combine all the .class files and the files in the META-INF folder , using

the tool ‘jar ’to create a file with an extension .jar.

Copy the .jar file into the application folder of WebLogic

Run the client program.

Observations:

For the Student and Library information systems, the services to be provided are to be

declared in the remote interface.

The services are to be implemented in the bean classes.

For the implementation part, the data retrieval is to be done by getting connected to

the database using JDBC.

For the Student Information System, the input would be the student ID and the output

would be the relevant information of the student.

Results: In case of the Library System, the book-ID would be given as input and the

relevant information of the book is to be retrieved as output.

4. Developing an EJB for Library Information System.

AIM: Developing an EJB for Student Information System

Apparatus: J2SDK 1.5 Software, Myeclipse workbench Installer

17

Weblogic application server 8.1, NetBeans IDE


Flow:

Enterprise Java Beans (EJB)

EJB components are designed to encapsulate business logic, and to protect the

application developer from having to worry about many system-level issues like

transactions, security, etc.

An EJB is just a collection of Java classes and XML file, bundled into a single unit.

An EJB runs in an EJB container. The EJB container runs within an application

server and takes responsibility for system-level issues.

EJB specification is intended to provide enterprise-level services.

EJBs provide persistence services.

There are three types of EJBs. Session Beans – stateful and stateless, message driven

beans and, Entity beans.

The Session and Entity beans must have two interfaces: Home and Remote Interface.

The Remote and Home interfaces can be used to access the EJB either remotely or

locally within the same container.Programming:The following is a sample

application using EJB:// Program to declare the Remote interfaceimport

java.rmi.RemoteException;import javax.ejb.EJBObject;public interface Hello

extends EJBObject{ public String sayHello(String str)throws

RemoteException;}// Program to declare the Home interfaceimport

java.rmi.RemoteException;import javax.ejb.EJBHome;import

javax.ejb.CreateException;public interface HelloHome extends EJBHome{ public

Hello create() throws RemoteException,CreateException;}// Program to implement

the beanimport java.rmi.RemoteException;import javax.ejb.SessionBean;import

javax.ejb.SessionContext;import javax.ejb.CreateException;public class HelloBean

implements SessionBean{ private SessionContext ctx; public void

ejbActivate() { System.out.println("Hello Bean:Activated"); }

public void ejbPassivate() { System.out.println("Hello

Bean:Passivated"); } public void setSessionContext(SessionContext sc)

18

{ ctx=sc; System.out.println("Hello Bean:Session Context");

} public void ejbRemove() { System.out.println("Hello

Bean:Removed");} public void ejbCreate() throws CreateException {

System.out.println("Hello Bean:Created"); } public String

sayHello(String str)throws RemoteException {

System.out.println("Hello Bean:Say"); return "Hello:"+str; }}//

Program to develop the client applicationimport java.rmi.*;import java.util.*;import

javax.ejb.*;import javax.rmi.*;import javax.naming.*;public class HelloClient{

public static void main(String args[]) { Properties p=new

Properties();

p.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextF

actory"); p.put(Context.PROVIDER_URL,"t3://localhost:7001");

try { InitialContext ctx=new InitialContext(p);

Object obj=ctx.lookup("HelloBean"); Class cls=HelloHome.class;

Object o=PortableRemoteObject.narrow(obj,cls); HelloHome

h=(HelloHome)o; Hello r=h.create(); String

result=r.sayHello(args[0]); System.out.println(result);

r.remove(); } catch (Exception e)

{ e.printStackTrace(); }

}}Procedure:For the execution of the above application the following steps are to

be carried out:

Compile all the java programs.

For generating the component , open the Weblogic Builder tool

Open the directory where all the .class files are stored. The builder tool

will automatically recognize the bean class and would prompt for creation

of the deployment descriptor.

Click on save and close. After this the tool will create a folder META-INF

with the files ejb-jar.xml and weblogic-ejb-jar.xml.

Combine all the .class files and the files in the META-INF folder , using

the tool ‘jar ’to create a file with an extension .jar.

19

Copy the .jar file into the application folder of WebLogic

Run the client program.

Observations:

For the Student and Library information systems, the services to be provided are to be

declared in the remote interface.

The services are to be implemented in the bean classes.

For the implementation part, the data retrieval is to be done by getting connected to

the database using JDBC.

For the Student Information System, the input would be the student ID and the output

would be the relevant information of the student.

Results:

In case of the Library System, the book-ID would be given as input and the relevant

information of the book is to be retrieved as output.

5. Creation Of An Active-x Control For Time Table

AIM: Creation of an Active-x Control for Time Table

Apparatus: Microsoft Visual Studio 2005

Programming:

TIME TABLE PROGRAM

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

20

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Data.OleDb;

namespace TimeTable

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)

{

switch (comboBox1.SelectedIndex)

{

case 0:

comboBox2.Items.Clear();

comboBox2.Items.Add("1styear");

comboBox2.Items.Add("2ndyear");

comboBox2.Items.Add("3rdyear");

break;

case 1:




break;

case 2:



21


comboBox2.Items.Add("3rdyear");

comboBox2.Items.Add("4thyear");

break;

}

}

private void Form1_Load(object sender, EventArgs e)

{

}


{

OleDbConnection cn = new OleDbConnection("user

id=scott;password=tiger;provider=msdaora.1");

string t = "select * from " + comboBox1.SelectedItem +

comboBox2.SelectedItem;

//MessageBox.Show(t);

OleDbDataAdapter da = new OleDbDataAdapter(t, cn);

DataSet ds = new DataSet();

da.Fill(ds, "timetable");

dataGridView1.DataSource = ds.Tables["timetable"];

}

private void label1_Click(object sender, EventArgs e)

{

}

}

}

Result & Observation:

22

6. Developing A Component For Converting Currency Values Using

COM/.NET

AIM: Developing a component for converting currency values using com .net


Programming:

CURRENCY TRANSLATOR PROGRAM

using System;


23


using System.Data;


using System.Linq;

using System.Text;


namespace currencytranslator

{


{

public Form1()

{


}

private void button1_Click(object sender, EventArgs e)

{

textBox2.Text = ((Double.Parse(textBox1.Text))/43.50).ToString();

}


{

textBox4 .Text = ((Double.Parse(textBox3.Text)) * 43.50).ToString();

}


{

}

}

}

Result& Observations:

24

7. Developing A Component For Browsing The CD Catalog Using

COM/.NET

AIM: Developing a component for browsing the CD catalog using com .net


Programming:

CD CATALOGUE PROGRAM

25

using System;



using System.Data;


using System.Linq;

using System.Text;


using System.IO;

namespace CDCatalogue

{


{

public Form1()

{


}

private void label1_Click(object sender, EventArgs e)

{

}


{

string s = comboBox1.SelectedItem.ToString();

listBox1.Items.Clear();

label2.Text = s;

try

{

string[] x = Directory.GetDirectories(s);

for (int i = 0; i < x.Length; i++)

{

DirectoryInfo di = new DirectoryInfo(x[i]);

26

listBox1.Items.Add(di.Name );

}

}

catch (IOException io)

{

MessageBox.Show(io.Message);

}

}


{

string x = "D:\\";

string[] f = Directory.GetDirectories(x);

for (int i = 0; i < f.Length; i++)

{

comboBox1.Items.Add(f[i]);

}

}

private void listBox1_SelectedIndexChanged(object sender, EventArgs e)

{

listBox2.Items.Clear();

string t = comboBox1.SelectedItem + "\\" + listBox1.SelectedItem;

label3.Text = t;

string[] x = Directory.GetFiles(t);

for (int i = 0; i < x.Length; i++)

{

FileInfo f = new FileInfo(x[i]);

listBox2.Items.Add(f.Name);

}

}

private void listBox2_SelectedIndexChanged(object sender, EventArgs e)

{

27

}

}

}

Result & Observations:

8. Developing A Component For Retrieving Information From

Message Box Using DCOM/.NET

AIM: developing a component for retrieving information from message box using

dcom .net


Programming:

Message Box Program…….

28

using System;



using System.Data;


using System.Linq;

using System.Text;


namespace msgbox

{


{

public Form1()

{


}


{

MessageBox.Show(textBox1.Text);

MessageBox.Show("Successfully submitted.");

}

}

}

Result& Observations:

29

9. Developing A Middleware Component For Retrieving Stock

Market Exchange Information Using CORBA

30

AIM: developing a middleware component for retrieving stock market exchange

information using CORBA


Flow:

CORBA (Common Object Request Broker Architecture)

CORBA is a specification that defines how distributed objects can interoperate.

CORBA specification is controlled by OMG.

CORBA objects can be written in almost any language and can exist on almost any

platform.

Language Independence is possible using the construction of interfaces to objects

using the Interface Definition Language (ICL). The only requirement is a bridge

between the natural language and IDL.

ORB (Object Request Broker) is at the core of CORBA. This is the principal

component for the transmission of information between the client and the server of

the CORBA application.

The Java IDL enables distributed Java applications to transparently invoke

operations or remote network services, using the industry standard IDL and IIOP.

Programming:

The following is a sample application using CORBA:

module hello

{

// this is a interface and all the method which are called from client and executed

at the server are define in it.

interface Hello

{

// the return type and parameter (in , out , inout ) are idl data type

string displayDate();

float displayResult(in float f1, in float f2);

31

};

// an interface can have more than one method

};

// A module can have more than one interface

// implementation class

import hello.*;

import org.omg.CORBA.*;

import java.util.*;

public class HelloImpl extends _HelloImplBase

{

public String displayDate()

{

return " " + new Date();

}

public float displayResult(float f1, float f2)

{

return f1 * f2;

}

}

// Program to implement the Client

import hello.*;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;


import java.io.*;

public class HelloClient

{

static Hello helloImpl;


{

32

try

{

// create and initialize the ORB

ORB orb = ORB.init(args, null);

// get the root naming context

org.omg.CORBA.Object objRef =

orb.resolve_initial_references("NameService");

NamingContext ncRef = NamingContextHelper.narrow(objRef);

// resolve the Object Reference in Naming

NameComponent nc = new NameComponent("Date", "");

NameComponent path[] = {nc};

Hello helloImpl = HelloHelper.narrow(ncRef.resolve(path));

System.out.println(helloImpl.displayDate());

BufferedReader br = new BufferedReader( new


System.out.println("Enter the first float value : ");

float f_val1 = Float.parseFloat(br.readLine());

System.out.println("Enter the second float value : ");


System.out.println("The result is : " +

helloImpl.displayResult(f_val1,f_val2));

}

catch (Exception e)

{

System.out.println("ERROR : " + e) ;

e.printStackTrace(System.out);

}

}

}

// Program to implement the Server

import hello.*;

33




import java.util.Properties;

public class HelloServer

{


{

try

{



// create servant and register it with the ORB

HelloImpl helloImpl = new HelloImpl();





Hello href = HelloHelper.narrow(helloImpl);

// bind the Object Reference in Naming



ncRef.rebind(path, href);

System.out.println("HelloServer ready and waiting ...");

// wait for invocations from clients

orb.run();

}

catch (Exception e)

{

System.err.println("ERROR: " + e);

34


}

System.out.println("HelloServer Exiting ...");

}

}

Procedure:

The following steps are to be carried out to execute the above application:

1) Firstly, the IDL file is to be converted into a Java format. For doing so the following

command is used - idlj -fall -oldImpBase hello.idl.

2) After this a set of Java classes are created in a separate folder by name Hello.

3) All the java files, including those in the Hello folder, are to be compiled using the

following command - avac *.java hello\*.java.

4) The ORB directory service is now started using the following command - start orbd

-ORBIntitialPort 1200.

5) The server is then started using the command - java HelloServer -ORBIntitialPort

1200.

6) The client is then started using the command - java HelloCli -ORBIntitialPort 1200.

Observations& results:

For the applications of Stock Market Exchange information and Bank balance

retrieval , the services are to be declared in the IDL nad to be implemented in the

implementation class.

A connection to the database is to be made, using JDBC, in the implementation

class, to retrieve the data.

Clients may be written in any of the natural languages and are to converted into the

IDL form using the compatible tools.

10. Developing a Middleware Component for Retrieving Bank Balance

Using CORBA

35

AIM: Developing a Middleware Component for Retrieving Bank Balance Using

CORBA


Flow:

CORBA (Common Object Request Broker Architecture)

CORBA is a specification that defines how distributed objects can interoperate.

CORBA specification is controlled by OMG.

CORBA objects can be written in almost any language and can exist on almost any

platform.

Language Independence is possible using the construction of interfaces to objects

using the Interface Definition Language (ICL). The only requirement is a bridge

between the natural language and IDL.

ORB (Object Request Broker) is at the core of CORBA. This is the principal

component for the transmission of information between the client and the server of

the CORBA application.

The Java IDL enables distributed Java applications to transparently invoke

operations or remote network services, using the industry standard IDL and IIOP.

Programming:

The following is a sample application using CORBA:

module hello

{

// this is a interface and all the method which are called from client and executed

at the server are define in it.

interface Hello

{

// the return type and parameter (in , out , inout ) are idl data type

string displayDate();

36

float displayResult(in float f1, in float f2);

};

// an interface can have more than one method

};

// A module can have more than one interface

// implementation class

import hello.*;


import java.util.*;

public class HelloImpl extends _HelloImplBase

{

public String displayDate()

{

return " " + new Date();

}

public float displayResult(float f1, float f2)

{

return f1 * f2;

}

}

// Program to implement the Client

import hello.*;

37




import java.io.*;

public class HelloClient

{

static Hello helloImpl;


{

try

{







// resolve the Object Reference in Naming



Hello helloImpl = HelloHelper.narrow(ncRef.resolve(path));

System.out.println(helloImpl.displayDate());

BufferedReader br = new BufferedReader( new


System.out.println("Enter the first float value : ");


System.out.println("Enter the second float value : ");


System.out.println("The result is : " +

helloImpl.displayResult(f_val1,f_val2));

38

}

catch (Exception e)

{

System.out.println("ERROR : " + e) ;


}

}

}

// Program to implement the Server

import hello.*;




import java.util.Properties;

public class HelloServer

{


{

try

{



// create servant and register it with the ORB

HelloImpl helloImpl = new HelloImpl();





Hello href = HelloHelper.narrow(helloImpl);

39

// bind the Object Reference in Naming



ncRef.rebind(path, href);

System.out.println("HelloServer ready and waiting ...");

// wait for invocations from clients

orb.run();

}

catch (Exception e)

{

System.err.println("ERROR: " + e);


}

System.out.println("HelloServer Exiting ...");

}

}

Procedure:

The following steps are to be carried out to execute the above application:

1) Firstly, the IDL file is to be converted into a Java format. For doing so the following

command is used - idlj -fall -oldImpBase hello.idl.

2) After this a set of Java classes are created in a separate folder by name Hello.

3) All the java files, including those in the Hello folder, are to be compiled using the

following command - avac *.java hello\*.java.

4) The ORB directory service is now started using the following command - start orbd

-ORBIntitialPort 1200.

5) The server is then started using the command - java HelloServer -ORBIntitialPort

1200.

6) The client is then started using the command - java HelloCli -ORBIntitialPort 1200.

Observations& result:

40

For the applications of Stock Market Exchange information and Bank balance

retrieval, the services are to be declared in the IDL and to be implemented in the

implementation class.

A connection to the database is to be made, using JDBC, in the implementation

class, to retrieve the data.

Clients may be written in any of the natural languages and are to converted into the

IDL form using the compatible tools.

41

MWT Lab Manual1

Documents

Transcript of MWT Lab Manual1