|
Advanced
Object Oriented System
This illustrates CORBA
two technique to implement the Server i.e.: Tie Approach and the Implementation approach.
To View implementation and Java doc click here
Description : Here we use N number of counters to implement tie and
implementation approach of CORBA. Counter is taken as data structure of ORBIX(version 3.0
for Java) as sequence or array of long datatype of size N. For each counter ,there are the
operation to initialize the counter to a given value k, Increment the value of the counter
by value m, retrieve the values for each counter and dump the counter (using Holder
classes for the array and sequence).This is totally menu driven. Application will launch
the server by itself and you can perform various operation on it. Exception handling is
used for incorrect clients. It is implemented by using both tie and implementation
approach.
To View Report and Presentation click here.
This is a simple bank application to debit and credit transaction
for the banking machine.This is to demonstrate the use of CORBA with JDBC. This is a small
application which is using two Protocols CORBA and JDBC. It has a multithreaded client.
Each client thread coordinated with the server as well as the database. In this main
client thread we creates two threads database thread and callback threads. Database thread
established a connection to the database and callback thread is used to listen to the
server for the callbacks. There is a multiconsole applet(server side code) which is
coordinating the server. The multiconsole applet uses CORBA to connect to the server.
Multiconsole Applet is sending request to the server to start the transaction. Now the
server which was listen by the callback thread send the request to this thread at the
client side which transfer this request to the database thread to start the execution on
the MS ACCESS database and start listening back to the server. So this is a totally
multithreaded scenario using CORBA, JDBC and callbacks.
To view Java documentation
click here
Description: In this we create a framework in which a student (a client)
can use an applet or application to displays her/his marks (for multiple courses). This
applet is automatically updated (using callbacks) when ever there is a change in students
marks from the server. Each student has its ID and password to login to the system.
Administrator can also login but it has more privilege then the student. Administrator can
add, selete and modify student information such as course he/she is registered, marks for
these courses and password etc. Persistence of the object is using file. If you want to
Shut down the server then everything is saved into the file.
This illustrates the use of Bridge Design Patterns and change of data
structure at the run time. Persistence of the objects is maintained in the file. Intensive
use of inheritance, containers and exception handling is used to built up the system.
Description : Consider a company that keeps tracks of its staff
consisting of employees and volunteers. Everybody has two immutable attributes :a name and
an address, employees (unlike volunteers ) additionally have a SIN immutable attributes.
Employee are paid a salary(per month) or wages(per hours). The following menu operations
are available in user defined data structure(single link list) such as hiring a employee,
hiring an volunteer, hiring a contract employee, raising a salary/wage of a
permanent/contract employee, change of data structure at the run time from list to array,
saving the object into the file and retrieving from the file. The design should be
flexible for the change in either case i.e.: accommodate other kinds of employees and
change of data structure. To check the Implementation detail
and Java documentation click here.
To calculate scalar product
of two vector using Multithreading capabilities of Java This illustrates the
use of multithreading in Java. This will try to determine the speed of using threads.
Description : This is used to calculate a scalar product of two vectors,
you multiple them component wise and can use up "n" threads, where n is the less
than equal to number of components of the vector. Design is in form of applet. The user
select the no of threads (between 1 to n ). Then clicking a start button to starts the
execution with all the available threads trying to execute the calculations as fast as
possible. Synchronization is done in order to maintain the integrity. As soon as thread
terminates, the corresponding components of the output vector is updated. There are two
version : Synchronous and Asynchronous. For the synchronous version the output vector is
displayed after all the components of output vector is available. For an asynchronous mode
this is done as soon as components are available. The timing fields shows the time spent
on the calculation of the scalar product by the corresponding thread. Initialization of
vector is done by the random number and each thread represent the unique color. To check the documentation and applet in action click here.
|