Design and Implementation of a Custom RPC Framework

This article introduces the concept of Remote Procedure Call (RPC) frameworks, explaining why they are essential for modern distributed systems and micro‑service architectures.

It adopts the three‑question (What, Where, Why) approach: RPC is a mechanism that allows a client to invoke methods on a remote service as if they were local; it is used wherever services need to communicate across process or machine boundaries; and it is needed to handle service registration, discovery, load balancing, fault tolerance, and other cross‑cutting concerns.

The basic components of an RPC framework are described: Service Provider, Service Consumer, and Registry. Additional extensions such as load balancers, circuit breakers, communication and serialization protocols are also listed.

The article details the role of a Registry (e.g., Zookeeper, Nacos, Consul, Eurake) and compares their consistency models, avalanche protection, multi‑data‑center support, and automatic instance deregistration.

For the Service Provider, the article discusses interface‑based versus service‑based registration, noting the shift toward service‑oriented registration in cloud‑native environments.

The Service Consumer section explains how it retrieves and caches service lists, applies load‑balancing strategies, performs serialization/deserialization, and invokes remote methods via a chosen communication protocol.

The communication framework is built on Netty (Java NIO), and the custom communication protocol is defined with a magic number, version, request type, and length‑prefixed payload.

Serialization options include XML, JSON, and Protobuf, with emphasis on JSON and Protobuf for their compactness and performance.

Load‑balancing strategies covered are round‑robin, random, weighted round‑robin, and consistent hashing.

Implementation choices for the sample RPC framework are summarized: Zookeeper as the Registry, service‑oriented registration, Dubbo‑style proxy generation for the consumer, Netty for networking, a length‑prefixed custom protocol, JSON/Protobuf serialization, and round‑robin/random load balancing. The framework is designed as Spring Boot SPI plugins for extensibility.

Several architecture diagrams and code snippets (provider registration, consumer proxy generation, load‑balancer SPI, Netty client/server) are presented to illustrate the overall structure and workflow.

In conclusion, the article provides a comprehensive overview of RPC fundamentals, component design, and a practical implementation that can be extended for performance tuning and scalability.