Java 2 Practical 8

Practical No.
8
1) Write a Java RMI (Remote Method Invocation) program to
calculate the factorial of a given number.
Program:
1)Interface:
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface FactorialInterface extends Remote {

long factorial(int n) throws RemoteException;
}
2)Class:
import java.rmi.server.UnicastRemoteObject;
public class FactorialImpl extends UnicastRemoteObject

implements FactorialInterface {
public FactorialImpl() throws RemoteException {
super();
}
@Override
public long factorial(int n) throws RemoteException {
if (n <= 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
}
3)Client Side :
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class FactorialClient {

public static void main(String[] args) {
try {
Registry registry =
LocateRegistry.getRegistry("localhost",2099);
FactorialInterface stub = (FactorialInterface)
registry.lookup("Factorial");
int num = 5;
long result = stub.factorial(num);
System.out.println("Factorial of " + num + " is: " + result);
} catch (Exception e) {
System.err.println("FactorialClient exception:");
e.printStackTrace();
}
}
}
4)Server Side:
public class FactorialServer {

try {
FactorialImpl obj = new FactorialImpl();
Registry registry = LocateRegistry.createRegistry(2099);
registry.rebind("Factorial", obj);
System.out.println("FactorialServer bound");
System.err.println("FactorialServer exception:");
}
}
}
Output:
i)
ii)

calculate the Fibonacci series.
Program:
1)Interface:
public interface FibonacciInterface extends Remote {

long getFibonacci(int n) throws RemoteException;
}
2)Class:
public class FibonacciImpl extends UnicastRemoteObject

implements FibonacciInterface {
public FibonacciImpl() throws RemoteException {
super();
}
@Override
public long getFibonacci(int n) throws RemoteException {
if (n <= 1)
return n;
return getFibonacci(n - 1) + getFibonacci(n - 2);
}
}
3)Client Side:
public class FibonacciClient {

try {
Registry registry =
LocateRegistry.getRegistry("localhost");
FibonacciInterface fibonacci = (FibonacciInterface)
registry.lookup("Fibonacci");
int n = 10; //
long result = fibonacci.getFibonacci(n);
System.out.println("Fibonacci(" + n + ") = " + result);
System.err.println("Client exception: " + e.toString());
}
}
}
4)Server Side:
public class FibonacciServer {

try {
FibonacciInterface fibonacci = new FibonacciImpl();
registry.rebind("Fibonacci", fibonacci);
System.out.println("Server started...");
System.err.println("Server exception: " + e.toString());
}
}
}
Output:
i)
ii)

calculate the addition of two numbers.
Program:
1)Interface:
public interface AdditionInterface extends Remote {

int add(int a, int b) throws RemoteException;
}
2)Class:
public class AdditionImpl extends UnicastRemoteObject

implements AdditionInterface {
public AdditionImpl() throws RemoteException {
super();
}
@Override
public int add(int a, int b) throws RemoteException {
return a + b;
}
}
3)Client Side:
public class AdditionClient {

try {
Registry registry = LocateRegistry.getRegistry("localhost");
AdditionInterface addition = (AdditionInterface)
registry.lookup("Addition");
int a = 5;
int b = 7;
int result = addition.add(a, b);
System.out.println("Result of adding " + a + " and " + b + " is: " +
result);
}
}
}
4)Server Side:
public class AdditionServer {

try {
AdditionInterface addition = new AdditionImpl();
registry.rebind("Addition", addition);
}
}
}
Output:
i)
ii)

calculate the subtraction of two numbers.
Program:
1)Interface:
public interface SubtractionInterface extends Remote {

int subtract(int a, int b) throws RemoteException;
}
2)Class:
public class SubtractionImpl extends UnicastRemoteObject

implements SubtractionInterface {
public SubtractionImpl() throws RemoteException {
super();
}
@Override
public int subtract(int a, int b) throws RemoteException {
return a - b;
}
}
3)Client Side:
public class SubtractionClient {

try {
Registry registry = LocateRegistry.getRegistry("localhost");
SubtractionInterface subtraction = (SubtractionInterface)
registry.lookup("Subtraction");
int a = 10;
int b = 5;
int result = subtraction.subtract(a, b);
System.out.println("Result of subtracting " + b + " from " + a +
" is: " + result);
}
}
}
4)Server Side:
public class SubtractionServer {

try {
SubtractionInterface subtraction = new SubtractionImpl();
registry.rebind("Subtraction", subtraction);
}
}
}

Java 2 Practical 8

Uploaded by

Copyright:

Available Formats

You might also like

Java 2 Practical 8

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java 2 Practical 8

Uploaded by

Copyright:

Available Formats

Practical No.

public interface FactorialInterface extends Remote {

public class FactorialImpl extends UnicastRemoteObject

public class FactorialClient {

public class FactorialServer {

2) Write a Java RMI (Remote Method Invocation) program to

public interface FibonacciInterface extends Remote {

public class FibonacciImpl extends UnicastRemoteObject

public class FibonacciClient {

public class FibonacciServer {

3) Write a Java RMI (Remote Method Invocation) program to

public interface AdditionInterface extends Remote {

public class AdditionImpl extends UnicastRemoteObject

public class AdditionClient {

public class AdditionServer {

4) Write a Java RMI (Remote Method Invocation) program to

public interface SubtractionInterface extends Remote {

public class SubtractionImpl extends UnicastRemoteObject

public class SubtractionClient {

public class SubtractionServer {

You might also like