Understanding RPC Communication: Roles, Process, and Framework Comparison

Understanding RPC Communication

RPC (Remote Procedure Call) is a protocol that enables a node to request services from another node over a network, effectively allowing a client to invoke functions on a remote server as if they were local.

1. What Is RPC Communication?

It involves a client calling a remote service provider, with the request and response transmitted as binary data over the network.

2. RPC Communication Details

2.1 Roles and Functions

Three main roles exist in an RPC framework:

Provider (Service) : Exposes the service.

Consumer (Client) : Calls the remote service.

Registry : Handles service registration and discovery.

2.2 RPC Call Flow

The typical synchronous RPC call proceeds through ten steps:

Client invokes the service via a local‑style interface.

Client stub packages method name and parameters into a network‑transmittable message (serialization to byte[]).

Client sends the message to the server via sockets.

Server stub receives and decodes the message (deserialization).

Server stub calls the local service implementation.

Service executes and returns the result to the server stub.

Server stub serializes the result into a response message.

Server sends the response back to the client via sockets.

Client stub receives and decodes the response.

Client obtains the final result.

The goal of an RPC framework is to hide steps 2, 3, 4, 7, 8, and 9 from the developer.

2.3 Multi‑Service RPC Communication Model

Illustrates how requests are routed through naming services and load balancers before reaching the appropriate service instance.

2.4 Technologies Used in RPC

Dynamic Proxy : Used to generate client and server stubs (JDK proxy, CGLIB, Javassist).

Serialization : Converts Java objects to byte[] and back.

NIO : Netty is a common underlying I/O framework.

Service Registry : Optional components like Redis or Zookeeper for registration and discovery.

2.5 Differences Between RPC and Local Function Calls

Key distinctions include:

Addressing : RPC uses IP/port routing plus function routing, while local calls use memory pointers.

Data Transfer : RPC transmits serialized byte streams; local calls pass in‑memory objects.

Error Handling : RPC must handle timeouts, retries, circuit breakers, authentication, and overload protection; local calls only deal with exceptions.

Debugging : RPC relies on distributed tracing, monitoring, and centralized logs; local calls use breakpoints and local logs.

Performance Optimizations : RPC requires connection pools, multiplexing, thread pools, non‑blocking I/O, etc.; local calls benefit from compiler optimizations.

2.6 RPC Framework Call Flow Analysis

2.6.1 Simple Version

Implementation steps:

Client creates a channel and discovers service instances via a naming service.

Client serializes request data.

Load balancer selects an upstream instance and establishes a connection.

Client sends the request.

Server receives and deserializes the request.

Server processes the request and generates a response.

Server serializes and sends the response back.

Client receives and deserializes the response.

2.6.2 Complex Version

Beyond basic communication, mature RPC frameworks also provide service governance features such as registration & discovery, fault injection, timeout/retry, load balancing, connection management, health checks, authentication, rate limiting, function routing, protocol adaptation, and parameter validation.

2.7 Comparison of Mainstream RPC Frameworks

Popular frameworks include Dubbo (Alibaba), gRPC (Google), brpc (Baidu), and Thrift (Meta). They differ in company backing, transport protocols (TCP/HTTP vs. HTTP/2), serialization formats (custom extensible vs. protobuf), supported languages, and primary strengths such as service governance, cross‑language support, high performance, and extensibility.

2.8 Differences with RESTful APIs

RPC is typically used for internal service calls, offering low latency and high throughput.

RESTful HTTP APIs target external consumers, browsers, mobile apps, and third‑party integrations.

RPC advantages include persistent connections, built‑in service registration & discovery, stronger security, and seamless microservice support.

Conclusion

This article covered the concept, principles, and capabilities of RPC, introduced major industry frameworks, and prepared the ground for a follow‑up tutorial that will demonstrate using Dubbo to implement inter‑service communication.