What is RMI? how does distributed application created using RMI? Explain with an example.

 RMI (Remote Method Invocation) is a Java API that enables distributed applications to communicate and interact with each other over a network. It allows Java objects to invoke methods on objects running on remote machines, just as if they were invoking methods on local objects.

In RMI, a client sends a request to a remote object, which then processes the request and sends a response back to the client. The communication between the client and the remote object is transparent to the developer, as the RMI system handles all the necessary details.

To create a distributed application using RMI, we need to follow these steps:

1. Define the remote interface:

The remote interface is a Java interface that declares the methods that can be invoked remotely by clients. These methods should throw RemoteException, which is a checked exception indicating that a remote error has occurred. The remote interface should extend the java.rmi.Remote interface.

2. Implement the remote interface:

The implementation of the remote interface should be provided by a class that extends java.rmi.server.UnicastRemoteObject. This class provides the necessary functionality to export the object and make it available for remote invocation.

3. Register the remote object:

The remote object should be registered with the RMI registry using the java.rmi.Naming class. The Naming class provides a simple way to bind remote objects to names in the registry.

4. Write the client code:

The client code should look up the remote object in the registry using the Naming class, cast it to the remote interface type, and then invoke the remote methods on it.

Example:

Let's consider a simple example of a calculator application that allows clients to perform arithmetic operations on two numbers using RMI.

1. Define the remote interface:

import java.rmi.*;
public interface Calculator extends Remote {
    public int add(int a, int b) throws RemoteException;
    public int subtract(int a, int b) throws RemoteException;
}

2. Implement the remote interface:

import java.rmi.*;
import java.rmi.server.*;
public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    public CalculatorImpl() throws RemoteException {}
    public int add(int a, int b) throws RemoteException {
        return a + b;
    }
    public int subtract(int a, int b) throws RemoteException {
        return a - b;
    }
}

3. Register the remote object:

import java.rmi.*;
public class CalculatorServer {
    public static void main(String[] args) {
        try {
            Calculator c = new CalculatorImpl();
            Naming.rebind("CalculatorService", c);
        } catch (Exception e) {
            System.out.println("Error: " + e);
        }
    }
}

4. Write the client code:

import java.rmi.*;
public class CalculatorClient {
    public static void main(String[] args) {
        try {
            Calculator c = (Calculator) Naming.lookup("CalculatorService");
            int sum = c.add(5, 10);
            int difference = c.subtract(5, 10);
            System.out.println("Sum: " + sum);
            System.out.println("Difference: " + difference);
        } catch (Exception e) {
            System.out.println("Error: " + e);
        }
    }
}

In this example, the server application registers the CalculatorImpl object with the RMI registry using the Naming class, and the client application looks up the CalculatorImpl object in the registry and invokes its remote methods.