Java RMI (Remote Method Invocation)

Remote Method Invocation (RMI) is a Java-specific mechanism that lets an object living in one Java Virtual Machine call a method on an object living in a different JVM — potentially on an entirely different machine — as though it were a normal local method call. RMI handles the underlying network communication, parameter serialization, and result marshaling transparently.

RMI was a significant part of enterprise Java in the late 1990s and early 2000s, and it still appears in legacy systems and in interview questions about distributed computing concepts. However, it is largely legacy technology today: modern distributed systems overwhelmingly use REST APIs, gRPC, or message queues instead, because those approaches are language-agnostic, easier to secure across networks, and better supported by modern tooling. This lesson presents RMI as historical/interview knowledge rather than a current best practice.

Why it matters

RMI is mostly found in older enterprise systems, but the idea it introduced is the basis of everything that replaced it. Calling a method that actually runs on another machine, through a local stub that sends the arguments over the network, is exactly what gRPC and REST clients do today. Understanding RMI makes those easier to learn, and you may still have to maintain it.

The Basic Pieces of RMI

An RMI application is built from a small number of cooperating pieces.

• Remote interface — an interface extending java.rmi.Remote, whose methods each declare throws RemoteException to account for network failures.
• Remote implementation — a class implementing that interface, typically extending UnicastRemoteObject, which provides the machinery to receive and respond to remote calls.
• RMI Registry — a simple naming service (started with the rmiregistry tool, or LocateRegistry.createRegistry()) where a server binds a name to a remote object reference, and a client looks that name up to obtain a proxy (stub) for the remote object.
• Stub — a client-side proxy object that implements the same remote interface; calling a method on the stub actually serializes the call and sends it over the network to the real object.

How a Call Flows

A server creates an instance of the remote implementation and binds it to a name in the RMI registry. A client looks up that name in the registry (given the server's host and port) and receives a stub object implementing the shared remote interface. When the client calls a method on the stub, RMI serializes the method name and arguments, sends them over TCP to the server's JVM, the server executes the real method, and the result is serialized back to the client — all of this is hidden behind what looks like an ordinary Java method call.

Why RMI Is Considered Legacy Today

RMI ties both client and server to Java specifically (a client written in another language cannot easily call an RMI service), requires careful handling of classloading and serialization security, and does not play well with firewalls, load balancers, and modern cloud infrastructure the way HTTP-based protocols do. For these reasons, REST APIs (over HTTP/JSON), gRPC (over HTTP/2 with protocol buffers), and message queues (like Kafka or RabbitMQ for asynchronous communication) are the standard choices for new distributed systems. Knowing RMI is still valuable for understanding the concepts behind remote calls and for legacy codebases, but it should not be reached for in new projects.

Example

// --- Remote interface ---
import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculator extends Remote {
    int add(int a, int b) throws RemoteException;
}

// --- Remote implementation ---
import java.rmi.server.UnicastRemoteObject;
import java.rmi.RemoteException;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    protected CalculatorImpl() throws RemoteException {
        super();
    }

    public int add(int a, int b) throws RemoteException {
        return a + b;
    }
}

// --- Server: creates registry and binds the object ---
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.Naming;

public class Server {
    public static void main(String[] args) throws Exception {
        Registry registry = LocateRegistry.createRegistry(1099);
        Calculator calculator = new CalculatorImpl();
        Naming.rebind("rmi://localhost/CalculatorService", calculator);
        System.out.println("Calculator service is bound and ready.");
    }
}

// --- Client: looks up the object and calls it as if local ---
import java.rmi.Naming;

public class Client {
    public static void main(String[] args) throws Exception {
        Calculator calculator = (Calculator) Naming.lookup("rmi://localhost/CalculatorService");
        System.out.println("5 + 7 = " + calculator.add(5, 7));
    }
}

(Server terminal) Calculator service is bound and ready.
(Client terminal) 5 + 7 = 12

Exercise

Declare a remote interface Calculator with a method add, following both rules that RMI requires of a remote interface. The implementation is called directly here, without a registry, so the program runs in one JVM.

Expected output: 12

import java.rmi.Remote;
import java.rmi.RemoteException;

// TODO: declare the interface Calculator with a method: int add(int a, int b)
//       Rule 1: it must extend Remote
//       Rule 2: every method must declare RemoteException

class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) throws RemoteException {
        return a + b;
    }
}

public class RemoteInterfacePractice {
    public static void main(String[] args) throws RemoteException {
        Calculator calculator = new CalculatorImpl();
        System.out.println(calculator.add(5, 7));
    }
}

import java.rmi.Remote;
import java.rmi.RemoteException;

interface Calculator extends Remote {
    int add(int a, int b) throws RemoteException;
}

class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) throws RemoteException {
        return a + b;
    }
}

public class RemoteInterfacePractice {
    public static void main(String[] args) throws RemoteException {
        Calculator calculator = new CalculatorImpl();
        System.out.println(calculator.add(5, 7)); // 12
    }
}

Quick quiz

Interview questions